diff --git a/ThirdParty/zfp/CMakeLists.txt b/ThirdParty/zfp/CMakeLists.txt
deleted file mode 100644
index 9039e12c651ab9746530fe855466602520ba0b10..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/CMakeLists.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-vtk_module_third_party_internal(
-  LICENSE_FILES
-    "vtkzfp/LICENSE"
-  SPDX_LICENSE_IDENTIFIER
-    "BSD-3-Clause"
-  SPDX_COPYRIGHT_TEXT
-    "Copyright (c) 2014-2019, Lawrence Livermore National Security, LLC."
-  SPDX_DOWNLOAD_LOCATION
-    "git+https://gitlab.kitware.com/third-party/zfp.git@for/vtk-20190605-0.5.5"
-  VERSION
-    "0.5.5"
-  STANDARD_INCLUDE_DIRS)
-
-configure_file(
-  "${CMAKE_CURRENT_SOURCE_DIR}/vtk_zfp.h.in"
-  "${CMAKE_CURRENT_BINARY_DIR}/vtk_zfp.h")
-
-vtk_module_install_headers(
-  FILES "${CMAKE_CURRENT_BINARY_DIR}/vtk_zfp.h")
diff --git a/ThirdParty/zfp/Testing/CMakeLists.txt b/ThirdParty/zfp/Testing/CMakeLists.txt
deleted file mode 100644
index 35f9732a938a3b073bdf94e86007916ffcd31b49..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/Testing/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-add_subdirectory(Cxx)
diff --git a/ThirdParty/zfp/Testing/Cxx/CMakeLists.txt b/ThirdParty/zfp/Testing/Cxx/CMakeLists.txt
deleted file mode 100644
index bbd0f7ac83e4c17e4fea8fed5adbba7f07e40a79..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/Testing/Cxx/CMakeLists.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-vtk_add_test_cxx(vtkzfpCxxTests tests
-  NO_DATA NO_VALID NO_OUTPUT
-  TestIncludeZFP.cxx)
-vtk_test_cxx_executable(vtkzfpCxxTests tests)
diff --git a/ThirdParty/zfp/Testing/Cxx/TestIncludeZFP.cxx b/ThirdParty/zfp/Testing/Cxx/TestIncludeZFP.cxx
deleted file mode 100644
index c876d12ef92b597a75fc699d2968efe752d921fa..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/Testing/Cxx/TestIncludeZFP.cxx
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "vtk_zfp.h"
-
-#include <cstdlib>
-
-int TestIncludeZFP(int /*argc*/, char* /*argv*/[])
-{
-  return EXIT_SUCCESS;
-}
diff --git a/ThirdParty/zfp/update.sh b/ThirdParty/zfp/update.sh
deleted file mode 100755
index 8cd7463d0d30a83f6c30a1a20bd7c99dfe21d674..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/update.sh
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-set -x
-shopt -s dotglob
-
-readonly name="zfp"
-readonly ownership="Zfp Upstream <kwrobot@kitware.com>"
-readonly subtree="ThirdParty/$name/vtk$name"
-readonly repo="https://gitlab.kitware.com/third-party/zfp.git"
-readonly tag="for/vtk-20190605-0.5.5"
-readonly paths="
-.gitattributes
-CMakeLists.vtk.txt
-
-include/
-array/
-src/inline/
-src/template/
-src/share/
-src/*.c
-src/*.h
-
-LICENSE
-README.md
-README.kitware.md
-"
-
-extract_source () {
-    git_archive
-    pushd "$extractdir/$name-reduced"
-    mv -v CMakeLists.vtk.txt CMakeLists.txt
-    mv -v array/zfp/* include/zfp/
-    rmdir -v array/zfp/
-    mv -v array/* include/
-    rmdir -v array/
-    popd
-}
-
-. "${BASH_SOURCE%/*}/../update-common.sh"
diff --git a/ThirdParty/zfp/vtk.module b/ThirdParty/zfp/vtk.module
deleted file mode 100644
index f3dca65fdc86880a416c6e1ba2877fdb98e6e38e..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtk.module
+++ /dev/null
@@ -1,7 +0,0 @@
-NAME
-  VTK::zfp
-LIBRARY_NAME
-  vtkzfp
-TEST_DEPENDS
-  VTK::TestingCore
-THIRD_PARTY
diff --git a/ThirdParty/zfp/vtk_zfp.h.in b/ThirdParty/zfp/vtk_zfp.h.in
deleted file mode 100644
index 18d8234c956b3a511f019cb4e9fc5dd9897bcc46..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtk_zfp.h.in
+++ /dev/null
@@ -1,15 +0,0 @@
-// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
-// SPDX-License-Identifier: BSD-3-Clause
-#ifndef vtk_zfp_h
-#define vtk_zfp_h
-
-/* Use the zfp library configured for VTK.  */
-#cmakedefine01 VTK_MODULE_USE_EXTERNAL_vtkzfp
-
-#if VTK_MODULE_USE_EXTERNAL_vtkzfp
-# include <zfp.h>
-#else
-# include <vtkzfp/include/zfp.h>
-#endif
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/.gitattributes b/ThirdParty/zfp/vtkzfp/.gitattributes
deleted file mode 100644
index f3a990fba170ea628e3adf771d1f82988fbeffe8..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/.gitattributes
+++ /dev/null
@@ -1,2 +0,0 @@
-# XXX(kitware): Ignore whitespace issues.
-* -whitespace
diff --git a/ThirdParty/zfp/vtkzfp/CMakeLists.txt b/ThirdParty/zfp/vtkzfp/CMakeLists.txt
deleted file mode 100644
index 3423c692f34950940f6a8bd2ef406047d17137e5..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/CMakeLists.txt
+++ /dev/null
@@ -1,62 +0,0 @@
-set(sources
-  src/bitstream.c
-  src/block1.h
-  src/block2.h
-  src/block3.h
-  src/block4.h
-  src/decode1d.c
-  src/decode1f.c
-  src/decode1i.c
-  src/decode1l.c
-  src/decode2d.c
-  src/decode2f.c
-  src/decode2i.c
-  src/decode2l.c
-  src/decode3d.c
-  src/decode3f.c
-  src/decode3i.c
-  src/decode3l.c
-  src/decode4d.c
-  src/decode4f.c
-  src/decode4i.c
-  src/decode4l.c
-  src/encode1d.c
-  src/encode1f.c
-  src/encode1i.c
-  src/encode1l.c
-  src/encode2d.c
-  src/encode2f.c
-  src/encode2i.c
-  src/encode2l.c
-  src/encode3d.c
-  src/encode3f.c
-  src/encode3i.c
-  src/encode3l.c
-  src/encode4d.c
-  src/encode4f.c
-  src/encode4i.c
-  src/encode4l.c
-  src/traitsd.h
-  src/traitsf.h
-  src/zfp.c)
-
-vtk_module_add_module(VTK::zfp
-  SOURCES ${sources})
-target_include_directories(zfp
-  PRIVATE
-    "${CMAKE_CURRENT_SOURCE_DIR}/include")
-
-if (NOT WIN32 OR CYGWIN)
-  target_link_libraries(zfp
-    PRIVATE
-      m)
-endif ()
-if (WIN32)
-  target_compile_definitions(zfp
-    PRIVATE
-      ZFP_SOURCE)
-endif ()
-
-vtk_module_install_headers(
-  DIRECTORIES "include"
-  SUBDIR      "vtkzfp")
diff --git a/ThirdParty/zfp/vtkzfp/LICENSE b/ThirdParty/zfp/vtkzfp/LICENSE
deleted file mode 100644
index 093449a33882bdddac369d06d16b81734ae01f09..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/LICENSE
+++ /dev/null
@@ -1,57 +0,0 @@
-Copyright (c) 2014-2019, Lawrence Livermore National Security, LLC.
-Produced at the Lawrence Livermore National Laboratory.
-Written by Peter Lindstrom, Markus Salasoo, Matt Larsen, and Stephen Herbein.
-LLNL-CODE-663824.
-All rights reserved.
-
-This file is part of the zfp library.
-For details, see http://computation.llnl.gov/casc/zfp/.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice,
-this list of conditions and the disclaimer below.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-this list of conditions and the disclaimer (as noted below) in the
-documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the LLNS/LLNL nor the names of its contributors may
-be used to endorse or promote products derived from this software without
-specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED.  IN NO EVENT SHALL LAWRENCE LIVERMORE NATIONAL SECURITY,
-LLC, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-Additional BSD Notice
-
-1. This notice is required to be provided under our contract with the U.S.
-Department of Energy (DOE).  This work was produced at Lawrence Livermore
-National Laboratory under Contract No. DE-AC52-07NA27344 with the DOE.
-
-2. Neither the United States Government nor Lawrence Livermore National
-Security, LLC nor any of their employees, makes any warranty, express or
-implied, or assumes any liability or responsibility for the accuracy,
-completeness, or usefulness of any information, apparatus, product, or
-process disclosed, or represents that its use would not infringe
-privately-owned rights.
-
-3. Also, reference herein to any specific commercial products, process, or
-services by trade name, trademark, manufacturer or otherwise does not
-necessarily constitute or imply its endorsement, recommendation, or
-favoring by the United States Government or Lawrence Livermore National
-Security, LLC.  The views and opinions of authors expressed herein do not
-necessarily state or reflect those of the United States Government or
-Lawrence Livermore National Security, LLC, and shall not be used for
-advertising or product endorsement purposes.
diff --git a/ThirdParty/zfp/vtkzfp/README.kitware.md b/ThirdParty/zfp/vtkzfp/README.kitware.md
deleted file mode 100644
index 0a0472baf6b95bdfaf3c3b84d29a70b23e853d3a..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/README.kitware.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# ZFP for for VTK
-
-This branch contains changes required to embed the ZFP library into VTK. This
-includes changes made primarily to the build system to allow it to be embedded
-into another source tree as well as a header to facilitate mangling of the
-symbols to avoid conflicts with other copies of the library within a single
-process.
-
-  * Add attributes to pass commit checks within VTK.
-  * Add a CMake build system to the project.
-  * Mangle all exported symbols to have a `vtkzfp_` prefix.
diff --git a/ThirdParty/zfp/vtkzfp/README.md b/ThirdParty/zfp/vtkzfp/README.md
deleted file mode 100644
index 2fd5fa328967559a6708c892dd12761a7a9e14e5..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/README.md
+++ /dev/null
@@ -1,142 +0,0 @@
-ZFP
-===
-[![Travis CI Build Status](https://travis-ci.org/LLNL/zfp.svg?branch=develop)](https://travis-ci.org/LLNL/zfp)
-[![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/LLNL/zfp?branch=develop&svg=true)](https://ci.appveyor.com/project/salasoom/zfp)
-[![Documentation Status](https://readthedocs.org/projects/zfp/badge/?version=release0.5.5)](https://zfp.readthedocs.io/en/release0.5.5/?badge=release0.5.5)
-[![Codecov](https://codecov.io/gh/LLNL/zfp/branch/develop/graph/badge.svg)](https://codecov.io/gh/LLNL/zfp)
-
-INTRODUCTION
-------------
-
-zfp is an open source C/C++ library for compressed numerical arrays that
-support high throughput read and write random access.  zfp also supports
-streaming compression of integer and floating-point data, e.g., for
-applications that read and write large data sets to and from disk.
-zfp is primarily written in C and C++ but also includes Python and
-Fortran bindings.
-
-zfp was developed at Lawrence Livermore National Laboratory and is loosely
-based on the algorithm described in the following paper:
-
-    Peter Lindstrom
-    "Fixed-Rate Compressed Floating-Point Arrays"
-    IEEE Transactions on Visualization and Computer Graphics
-    20(12):2674-2683, December 2014
-    doi:10.1109/TVCG.2014.2346458
-
-zfp was originally designed for floating-point arrays only, but has been
-extended to also support integer data and could for instance be used to
-compress images and quantized volumetric data.  To achieve high compression
-ratios, zfp generally uses lossy but optionally error-bounded compression.
-Bit-for-bit lossless compression is also possible through one of zfp's
-compression modes.
-
-zfp works best for 2D and 3D arrays that exhibit spatial correlation, such as
-continuous fields from physics simulations, images, regularly sampled terrain
-surfaces, etc.  Although zfp also provides a 1D array class that can be used
-for 1D signals such as audio, or even unstructured floating-point streams,
-the compression scheme has not been well optimized for this use case, and
-rate and quality may not be competitive with floating-point compressors
-designed specifically for 1D streams.  zfp also supports compression of
-4D arrays.
-
-zfp is freely available as open source under a BSD license, as outlined in
-the file 'LICENSE'.  For more information on zfp and comparisons with other
-compressors, please see the
-[zfp website](https://computation.llnl.gov/projects/floating-point-compression).
-For bug reports, please consult the
-[GitHub issue tracker](https://github.com/LLNL/zfp/issues).
-For questions, comments, and requests, please contact
-[Peter Lindstrom](mailto:pl@llnl.gov).
-
-
-DOCUMENTATION
--------------
-
-Full
-[documentation](http://zfp.readthedocs.io/en/release0.5.5/)
-is available online via Read the Docs.  A
-[PDF](http://readthedocs.org/projects/zfp/downloads/pdf/release0.5.5/)
-version is also available.
-
-
-INSTALLATION
-------------
-
-zfp consists of three distinct parts: a compression library written in C;
-a set of C++ header files with C wrappers that implement compressed arrays;
-and a set of C and C++ examples.  The main compression codec is written in
-C and should conform to both the ISO C89 and C99 standards.  The C++ array
-classes are implemented entirely in header files and can be included as is,
-but since they call the compression library, applications must link with
-libzfp.
-
-On Linux, macOS, and MinGW, zfp is easiest compiled using gcc and gmake.
-CMake support is also available, e.g., for Windows builds.  See below for
-instructions on GNU and CMake builds.
-
-zfp has successfully been built and tested using these compilers:
-
-    gcc versions 4.4.7, 4.9.4, 5.5.0, 6.1.0, 6.4.0, 7.1.0, 7.3.0, 8.1.0
-    icc versions 15.0.6, 16.0.4, 17.0.2, 18.0.2, 19.0.0
-    clang versions 3.9.1, 4.0.0, 5.0.0, 6.0.0 
-    MinGW version 5.3.0
-    Visual Studio versions 14 (2015), 15 (2017)
-
-zfp conforms to various language standards, including C89, C99, C11,
-C++98, C++11, and C++14.
-
-NOTE: zfp requires 64-bit compiler and operating system support.
-
-## GNU builds 
-
-To build zfp using gcc, type
-
-    make
-
-from this directory.  This builds libzfp as a static library as well as
-utilities and example programs.  See documentation for complete build
-instructions.
-
-## CMake builds
-
-To build zfp using CMake on Linux or macOS, start a Unix shell and type
-
-    mkdir build
-    cd build
-    cmake ..
-    make
-
-To also build the examples, replace the cmake line with
-
-    cmake -DBUILD_EXAMPLES=ON ..
-
-To build zfp using Visual Studio on Windows, start a DOS shell, cd to the
-top-level zfp directory, and type
-
-    mkdir build
-    cd build
-    cmake ..
-    cmake --build . --config Release
-
-This builds zfp in release mode.  Replace 'Release' with 'Debug' to build
-zfp in debug mode.  See the instructions for Linux on how to change the
-cmake line to also build the example programs.
-
-## Testing
-
-To test that zfp is working properly, type
-
-    make test
-
-or using CMake
-
-    ctest
-
-If the compilation or regression tests fail, it is possible that some of the
-macros in the file 'Config' have to be adjusted.  Also, the tests may fail
-due to minute differences in the computed floating-point fields being
-compressed, which will be indicated by checksum errors.  If most tests
-succeed and the failures result in byte sizes and error values reasonably
-close to the expected values, then it is likely that the compressor is
-working correctly.
diff --git a/ThirdParty/zfp/vtkzfp/include/bitstream.h b/ThirdParty/zfp/vtkzfp/include/bitstream.h
deleted file mode 100644
index 3bd25214a78449f92e04c853c6261b9d2eeb40ea..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/bitstream.h
+++ /dev/null
@@ -1,96 +0,0 @@
-#ifndef ZFP_BITSTREAM_H
-#define ZFP_BITSTREAM_H
-
-#include <stddef.h>
-#include "zfp/types.h"
-#include "zfp/system.h"
-
-#include "vtk_zfp_mangle.h"
-
-/* forward declaration of opaque type */
-typedef struct bitstream bitstream;
-
-extern_ const size_t stream_word_bits; /* bit stream granularity */
-
-#ifndef inline_
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* allocate and initialize bit stream */
-bitstream* stream_open(void* buffer, size_t bytes);
-
-/* close and deallocate bit stream */
-void stream_close(bitstream* stream);
-
-/* make a copy of bit stream to shared memory buffer */
-bitstream* stream_clone(const bitstream* stream);
-
-/* pointer to beginning of stream */
-void* stream_data(const bitstream* stream);
-
-/* current byte size of stream (if flushed) */
-size_t stream_size(const bitstream* stream);
-
-/* byte capacity of stream */
-size_t stream_capacity(const bitstream* stream);
-
-/* number of words per block */
-size_t stream_stride_block(const bitstream* stream);
-
-/* number of blocks between consecutive blocks */
-ptrdiff_t stream_stride_delta(const bitstream* stream);
-
-/* read single bit (0 or 1) */
-uint stream_read_bit(bitstream* stream);
-
-/* write single bit */
-uint stream_write_bit(bitstream* stream, uint bit);
-
-/* read 0 <= n <= 64 bits */
-uint64 stream_read_bits(bitstream* stream, uint n);
-
-/* write 0 <= n <= 64 low bits of value and return remaining bits */
-uint64 stream_write_bits(bitstream* stream, uint64 value, uint n);
-
-/* return bit offset to next bit to be read */
-size_t stream_rtell(const bitstream* stream);
-
-/* return bit offset to next bit to be written */
-size_t stream_wtell(const bitstream* stream);
-
-/* rewind stream to beginning */
-void stream_rewind(bitstream* stream);
-
-/* position stream for reading at given bit offset */
-void stream_rseek(bitstream* stream, size_t offset);
-
-/* position stream for writing at given bit offset */
-void stream_wseek(bitstream* stream, size_t offset);
-
-/* skip over the next n bits */
-void stream_skip(bitstream* stream, uint n);
-
-/* append n zero-bits to stream */
-void stream_pad(bitstream* stream, uint n);
-
-/* align stream on next word boundary */
-size_t stream_align(bitstream* stream);
-
-/* flush out any remaining buffered bits */
-size_t stream_flush(bitstream* stream);
-
-/* copy n bits from one bit stream to another */
-void stream_copy(bitstream* dst, bitstream* src, size_t n);
-
-#ifdef BIT_STREAM_STRIDED
-/* set block size in number of words and spacing in number of blocks */
-int stream_set_stride(bitstream* stream, size_t block, ptrdiff_t delta);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !inline_ */
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/include/vtk_zfp_mangle.h b/ThirdParty/zfp/vtkzfp/include/vtk_zfp_mangle.h
deleted file mode 100644
index bc2e7874ac819412cbff655ffac56d24e5ac5697..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/vtk_zfp_mangle.h
+++ /dev/null
@@ -1,178 +0,0 @@
-#ifndef ZFP_MANGLE_H
-#define ZFP_MANGLE_H
-
-#define stream_align vtkzfp_stream_align
-#define stream_capacity vtkzfp_stream_capacity
-#define stream_close vtkzfp_stream_close
-#define stream_data vtkzfp_stream_data
-#define stream_flush vtkzfp_stream_flush
-#define stream_open vtkzfp_stream_open
-#define stream_pad vtkzfp_stream_pad
-#define stream_read_bit vtkzfp_stream_read_bit
-#define stream_read_bits vtkzfp_stream_read_bits
-#define stream_rewind vtkzfp_stream_rewind
-#define stream_rseek vtkzfp_stream_rseek
-#define stream_rtell vtkzfp_stream_rtell
-#define stream_size vtkzfp_stream_size
-#define stream_skip vtkzfp_stream_skip
-#define stream_stride_block vtkzfp_stream_stride_block
-#define stream_stride_delta vtkzfp_stream_stride_delta
-#define stream_word_bits vtkzfp_stream_word_bits
-#define stream_write_bit vtkzfp_stream_write_bit
-#define stream_write_bits vtkzfp_stream_write_bits
-#define stream_wseek vtkzfp_stream_wseek
-#define stream_wtell vtkzfp_stream_wtell
-#define zfp_codec_version vtkzfp_zfp_codec_version
-#define zfp_compress vtkzfp_zfp_compress
-#define zfp_decode_block_double_1 vtkzfp_zfp_decode_block_double_1
-#define zfp_decode_block_double_2 vtkzfp_zfp_decode_block_double_2
-#define zfp_decode_block_double_3 vtkzfp_zfp_decode_block_double_3
-#define zfp_decode_block_double_4 vtkzfp_zfp_decode_block_double_4
-#define zfp_decode_block_float_1 vtkzfp_zfp_decode_block_float_1
-#define zfp_decode_block_float_2 vtkzfp_zfp_decode_block_float_2
-#define zfp_decode_block_float_3 vtkzfp_zfp_decode_block_float_3
-#define zfp_decode_block_float_4 vtkzfp_zfp_decode_block_float_4
-#define zfp_decode_block_int32_1 vtkzfp_zfp_decode_block_int32_1
-#define zfp_decode_block_int32_2 vtkzfp_zfp_decode_block_int32_2
-#define zfp_decode_block_int32_3 vtkzfp_zfp_decode_block_int32_3
-#define zfp_decode_block_int32_4 vtkzfp_zfp_decode_block_int32_4
-#define zfp_decode_block_int64_1 vtkzfp_zfp_decode_block_int64_1
-#define zfp_decode_block_int64_2 vtkzfp_zfp_decode_block_int64_2
-#define zfp_decode_block_int64_3 vtkzfp_zfp_decode_block_int64_3
-#define zfp_decode_block_int64_4 vtkzfp_zfp_decode_block_int64_4
-#define zfp_decode_block_strided_double_1 vtkzfp_zfp_decode_block_strided_double_1
-#define zfp_decode_block_strided_double_2 vtkzfp_zfp_decode_block_strided_double_2
-#define zfp_decode_block_strided_double_3 vtkzfp_zfp_decode_block_strided_double_3
-#define zfp_decode_block_strided_double_4 vtkzfp_zfp_decode_block_strided_double_4
-#define zfp_decode_block_strided_float_1 vtkzfp_zfp_decode_block_strided_float_1
-#define zfp_decode_block_strided_float_2 vtkzfp_zfp_decode_block_strided_float_2
-#define zfp_decode_block_strided_float_3 vtkzfp_zfp_decode_block_strided_float_3
-#define zfp_decode_block_strided_float_4 vtkzfp_zfp_decode_block_strided_float_4
-#define zfp_decode_block_strided_int32_1 vtkzfp_zfp_decode_block_strided_int32_1
-#define zfp_decode_block_strided_int32_2 vtkzfp_zfp_decode_block_strided_int32_2
-#define zfp_decode_block_strided_int32_3 vtkzfp_zfp_decode_block_strided_int32_3
-#define zfp_decode_block_strided_int32_4 vtkzfp_zfp_decode_block_strided_int32_4
-#define zfp_decode_block_strided_int64_1 vtkzfp_zfp_decode_block_strided_int64_1
-#define zfp_decode_block_strided_int64_2 vtkzfp_zfp_decode_block_strided_int64_2
-#define zfp_decode_block_strided_int64_3 vtkzfp_zfp_decode_block_strided_int64_3
-#define zfp_decode_block_strided_int64_4 vtkzfp_zfp_decode_block_strided_int64_4
-#define zfp_decode_partial_block_strided_double_1 vtkzfp_zfp_decode_partial_block_strided_double_1
-#define zfp_decode_partial_block_strided_double_2 vtkzfp_zfp_decode_partial_block_strided_double_2
-#define zfp_decode_partial_block_strided_double_3 vtkzfp_zfp_decode_partial_block_strided_double_3
-#define zfp_decode_partial_block_strided_double_4 vtkzfp_zfp_decode_partial_block_strided_double_4
-#define zfp_decode_partial_block_strided_float_1 vtkzfp_zfp_decode_partial_block_strided_float_1
-#define zfp_decode_partial_block_strided_float_2 vtkzfp_zfp_decode_partial_block_strided_float_2
-#define zfp_decode_partial_block_strided_float_3 vtkzfp_zfp_decode_partial_block_strided_float_3
-#define zfp_decode_partial_block_strided_float_4 vtkzfp_zfp_decode_partial_block_strided_float_4
-#define zfp_decode_partial_block_strided_int32_1 vtkzfp_zfp_decode_partial_block_strided_int32_1
-#define zfp_decode_partial_block_strided_int32_2 vtkzfp_zfp_decode_partial_block_strided_int32_2
-#define zfp_decode_partial_block_strided_int32_3 vtkzfp_zfp_decode_partial_block_strided_int32_3
-#define zfp_decode_partial_block_strided_int32_4 vtkzfp_zfp_decode_partial_block_strided_int32_4
-#define zfp_decode_partial_block_strided_int64_1 vtkzfp_zfp_decode_partial_block_strided_int64_1
-#define zfp_decode_partial_block_strided_int64_2 vtkzfp_zfp_decode_partial_block_strided_int64_2
-#define zfp_decode_partial_block_strided_int64_3 vtkzfp_zfp_decode_partial_block_strided_int64_3
-#define zfp_decode_partial_block_strided_int64_4 vtkzfp_zfp_decode_partial_block_strided_int64_4
-#define zfp_decompress vtkzfp_zfp_decompress
-#define zfp_demote_int32_to_int16 vtkzfp_zfp_demote_int32_to_int16
-#define zfp_demote_int32_to_int8 vtkzfp_zfp_demote_int32_to_int8
-#define zfp_demote_int32_to_uint16 vtkzfp_zfp_demote_int32_to_uint16
-#define zfp_demote_int32_to_uint8 vtkzfp_zfp_demote_int32_to_uint8
-#define zfp_encode_block_double_1 vtkzfp_zfp_encode_block_double_1
-#define zfp_encode_block_double_2 vtkzfp_zfp_encode_block_double_2
-#define zfp_encode_block_double_3 vtkzfp_zfp_encode_block_double_3
-#define zfp_encode_block_double_4 vtkzfp_zfp_encode_block_double_4
-#define zfp_encode_block_float_1 vtkzfp_zfp_encode_block_float_1
-#define zfp_encode_block_float_2 vtkzfp_zfp_encode_block_float_2
-#define zfp_encode_block_float_3 vtkzfp_zfp_encode_block_float_3
-#define zfp_encode_block_float_4 vtkzfp_zfp_encode_block_float_4
-#define zfp_encode_block_int32_1 vtkzfp_zfp_encode_block_int32_1
-#define zfp_encode_block_int32_2 vtkzfp_zfp_encode_block_int32_2
-#define zfp_encode_block_int32_3 vtkzfp_zfp_encode_block_int32_3
-#define zfp_encode_block_int32_4 vtkzfp_zfp_encode_block_int32_4
-#define zfp_encode_block_int64_1 vtkzfp_zfp_encode_block_int64_1
-#define zfp_encode_block_int64_2 vtkzfp_zfp_encode_block_int64_2
-#define zfp_encode_block_int64_3 vtkzfp_zfp_encode_block_int64_3
-#define zfp_encode_block_int64_4 vtkzfp_zfp_encode_block_int64_4
-#define zfp_encode_block_strided_double_1 vtkzfp_zfp_encode_block_strided_double_1
-#define zfp_encode_block_strided_double_2 vtkzfp_zfp_encode_block_strided_double_2
-#define zfp_encode_block_strided_double_3 vtkzfp_zfp_encode_block_strided_double_3
-#define zfp_encode_block_strided_double_4 vtkzfp_zfp_encode_block_strided_double_4
-#define zfp_encode_block_strided_float_1 vtkzfp_zfp_encode_block_strided_float_1
-#define zfp_encode_block_strided_float_2 vtkzfp_zfp_encode_block_strided_float_2
-#define zfp_encode_block_strided_float_3 vtkzfp_zfp_encode_block_strided_float_3
-#define zfp_encode_block_strided_float_4 vtkzfp_zfp_encode_block_strided_float_4
-#define zfp_encode_block_strided_int32_1 vtkzfp_zfp_encode_block_strided_int32_1
-#define zfp_encode_block_strided_int32_2 vtkzfp_zfp_encode_block_strided_int32_2
-#define zfp_encode_block_strided_int32_3 vtkzfp_zfp_encode_block_strided_int32_3
-#define zfp_encode_block_strided_int32_4 vtkzfp_zfp_encode_block_strided_int32_4
-#define zfp_encode_block_strided_int64_1 vtkzfp_zfp_encode_block_strided_int64_1
-#define zfp_encode_block_strided_int64_2 vtkzfp_zfp_encode_block_strided_int64_2
-#define zfp_encode_block_strided_int64_3 vtkzfp_zfp_encode_block_strided_int64_3
-#define zfp_encode_block_strided_int64_4 vtkzfp_zfp_encode_block_strided_int64_4
-#define zfp_encode_partial_block_strided_double_1 vtkzfp_zfp_encode_partial_block_strided_double_1
-#define zfp_encode_partial_block_strided_double_2 vtkzfp_zfp_encode_partial_block_strided_double_2
-#define zfp_encode_partial_block_strided_double_3 vtkzfp_zfp_encode_partial_block_strided_double_3
-#define zfp_encode_partial_block_strided_double_4 vtkzfp_zfp_encode_partial_block_strided_double_4
-#define zfp_encode_partial_block_strided_float_1 vtkzfp_zfp_encode_partial_block_strided_float_1
-#define zfp_encode_partial_block_strided_float_2 vtkzfp_zfp_encode_partial_block_strided_float_2
-#define zfp_encode_partial_block_strided_float_3 vtkzfp_zfp_encode_partial_block_strided_float_3
-#define zfp_encode_partial_block_strided_float_4 vtkzfp_zfp_encode_partial_block_strided_float_4
-#define zfp_encode_partial_block_strided_int32_1 vtkzfp_zfp_encode_partial_block_strided_int32_1
-#define zfp_encode_partial_block_strided_int32_2 vtkzfp_zfp_encode_partial_block_strided_int32_2
-#define zfp_encode_partial_block_strided_int32_3 vtkzfp_zfp_encode_partial_block_strided_int32_3
-#define zfp_encode_partial_block_strided_int32_4 vtkzfp_zfp_encode_partial_block_strided_int32_4
-#define zfp_encode_partial_block_strided_int64_1 vtkzfp_zfp_encode_partial_block_strided_int64_1
-#define zfp_encode_partial_block_strided_int64_2 vtkzfp_zfp_encode_partial_block_strided_int64_2
-#define zfp_encode_partial_block_strided_int64_3 vtkzfp_zfp_encode_partial_block_strided_int64_3
-#define zfp_encode_partial_block_strided_int64_4 vtkzfp_zfp_encode_partial_block_strided_int64_4
-#define zfp_field_1d vtkzfp_zfp_field_1d
-#define zfp_field_2d vtkzfp_zfp_field_2d
-#define zfp_field_3d vtkzfp_zfp_field_3d
-#define zfp_field_4d vtkzfp_zfp_field_4d
-#define zfp_field_alloc vtkzfp_zfp_field_alloc
-#define zfp_field_dimensionality vtkzfp_zfp_field_dimensionality
-#define zfp_field_free vtkzfp_zfp_field_free
-#define zfp_field_metadata vtkzfp_zfp_field_metadata
-#define zfp_field_pointer vtkzfp_zfp_field_pointer
-#define zfp_field_precision vtkzfp_zfp_field_precision
-#define zfp_field_set_metadata vtkzfp_zfp_field_set_metadata
-#define zfp_field_set_pointer vtkzfp_zfp_field_set_pointer
-#define zfp_field_set_size_1d vtkzfp_zfp_field_set_size_1d
-#define zfp_field_set_size_2d vtkzfp_zfp_field_set_size_2d
-#define zfp_field_set_size_3d vtkzfp_zfp_field_set_size_3d
-#define zfp_field_set_size_4d vtkzfp_zfp_field_set_size_4d
-#define zfp_field_set_stride_1d vtkzfp_zfp_field_set_stride_1d
-#define zfp_field_set_stride_2d vtkzfp_zfp_field_set_stride_2d
-#define zfp_field_set_stride_3d vtkzfp_zfp_field_set_stride_3d
-#define zfp_field_set_stride_4d vtkzfp_zfp_field_set_stride_4d
-#define zfp_field_set_type vtkzfp_zfp_field_set_type
-#define zfp_field_size vtkzfp_zfp_field_size
-#define zfp_field_stride vtkzfp_zfp_field_stride
-#define zfp_field_type vtkzfp_zfp_field_type
-#define zfp_library_version vtkzfp_zfp_library_version
-#define zfp_promote_int16_to_int32 vtkzfp_zfp_promote_int16_to_int32
-#define zfp_promote_int8_to_int32 vtkzfp_zfp_promote_int8_to_int32
-#define zfp_promote_uint16_to_int32 vtkzfp_zfp_promote_uint16_to_int32
-#define zfp_promote_uint8_to_int32 vtkzfp_zfp_promote_uint8_to_int32
-#define zfp_read_header vtkzfp_zfp_read_header
-#define zfp_stream_align vtkzfp_zfp_stream_align
-#define zfp_stream_bit_stream vtkzfp_zfp_stream_bit_stream
-#define zfp_stream_close vtkzfp_zfp_stream_close
-#define zfp_stream_compressed_size vtkzfp_zfp_stream_compressed_size
-#define zfp_stream_flush vtkzfp_zfp_stream_flush
-#define zfp_stream_maximum_size vtkzfp_zfp_stream_maximum_size
-#define zfp_stream_mode vtkzfp_zfp_stream_mode
-#define zfp_stream_open vtkzfp_zfp_stream_open
-#define zfp_stream_params vtkzfp_zfp_stream_params
-#define zfp_stream_rewind vtkzfp_zfp_stream_rewind
-#define zfp_stream_set_accuracy vtkzfp_zfp_stream_set_accuracy
-#define zfp_stream_set_bit_stream vtkzfp_zfp_stream_set_bit_stream
-#define zfp_stream_set_mode vtkzfp_zfp_stream_set_mode
-#define zfp_stream_set_params vtkzfp_zfp_stream_set_params
-#define zfp_stream_set_precision vtkzfp_zfp_stream_set_precision
-#define zfp_stream_set_rate vtkzfp_zfp_stream_set_rate
-#define zfp_type_size vtkzfp_zfp_type_size
-#define zfp_version_string vtkzfp_zfp_version_string
-#define zfp_write_header vtkzfp_zfp_write_header
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp.h b/ThirdParty/zfp/vtkzfp/include/zfp.h
deleted file mode 100644
index f3105983de581e3c09bb11e0ab73d68c24fd967d..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp.h
+++ /dev/null
@@ -1,758 +0,0 @@
-/*
-** Copyright (c) 2014-2019, Lawrence Livermore National Security, LLC.
-** Produced at the Lawrence Livermore National Laboratory.
-** Authors: Peter Lindstrom, Markus Salasoo, Matt Larsen, Stephen Herbein.
-** LLNL-CODE-663824.
-** All rights reserved.
-**
-** This file is part of the zfp library.
-** For details, see http://computation.llnl.gov/casc/zfp/.
-**
-** Redistribution and use in source and binary forms, with or without
-** modification, are permitted provided that the following conditions are met:
-**
-** 1. Redistributions of source code must retain the above copyright notice,
-** this list of conditions and the disclaimer below.
-**
-** 2. Redistributions in binary form must reproduce the above copyright notice,
-** this list of conditions and the disclaimer (as noted below) in the
-** documentation and/or other materials provided with the distribution.
-**
-** 3. Neither the name of the LLNS/LLNL nor the names of its contributors may
-** be used to endorse or promote products derived from this software without
-** specific prior written permission.
-**
-** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-** ARE DISCLAIMED.  IN NO EVENT SHALL LAWRENCE LIVERMORE NATIONAL SECURITY,
-** LLC, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-** INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-**
-**
-** Additional BSD Notice
-**
-** 1. This notice is required to be provided under our contract with the U.S.
-** Department of Energy (DOE).  This work was produced at Lawrence Livermore
-** National Laboratory under Contract No. DE-AC52-07NA27344 with the DOE.
-
-** 2. Neither the United States Government nor Lawrence Livermore National
-** Security, LLC nor any of their employees, makes any warranty, express or
-** implied, or assumes any liability or responsibility for the accuracy,
-** completeness, or usefulness of any information, apparatus, product, or
-** process disclosed, or represents that its use would not infringe
-** privately-owned rights.
-**
-** 3. Also, reference herein to any specific commercial products, process, or
-** services by trade name, trademark, manufacturer or otherwise does not
-** necessarily constitute or imply its endorsement, recommendation, or
-** favoring by the United States Government or Lawrence Livermore National
-** Security, LLC.  The views and opinions of authors expressed herein do not
-** necessarily state or reflect those of the United States Government or
-** Lawrence Livermore National Security, LLC, and shall not be used for
-** advertising or product endorsement purposes.
-*/
-
-#ifndef ZFP_H
-#define ZFP_H
-
-#include "vtk_zfp_mangle.h"
-
-#include "zfp/types.h"
-#include "zfp/system.h"
-#include "bitstream.h"
-
-/* macros ------------------------------------------------------------------ */
-
-/* stringification */
-#define _zfp_str_(x) # x
-#define _zfp_str(x) _zfp_str_(x)
-
-/* library version information */
-#define ZFP_VERSION_MAJOR 0 /* library major version number */
-#define ZFP_VERSION_MINOR 5 /* library minor version number */
-#define ZFP_VERSION_PATCH 5 /* library patch version number */
-#define ZFP_VERSION_RELEASE ZFP_VERSION_PATCH
-
-/* codec version number (see also zfp_codec_version) */
-#define ZFP_CODEC 5
-
-/* library version number (see also zfp_library_version) */
-#define ZFP_VERSION \
-  ((ZFP_VERSION_MAJOR << 8) + \
-   (ZFP_VERSION_MINOR << 4) + \
-   (ZFP_VERSION_PATCH << 0))
-
-/* library version string (see also zfp_version_string) */
-#define ZFP_VERSION_STRING \
-  _zfp_str(ZFP_VERSION_MAJOR) "." \
-  _zfp_str(ZFP_VERSION_MINOR) "." \
-  _zfp_str(ZFP_VERSION_PATCH)
-
-/* default compression parameters */
-#define ZFP_MIN_BITS     1 /* minimum number of bits per block */
-#define ZFP_MAX_BITS 16657 /* maximum number of bits per block */
-#define ZFP_MAX_PREC    64 /* maximum precision supported */
-#define ZFP_MIN_EXP  -1074 /* minimum floating-point base-2 exponent */
-
-/* header masks (enable via bitwise or; reader must use same mask) */
-#define ZFP_HEADER_MAGIC  0x1u /* embed 64-bit magic */
-#define ZFP_HEADER_META   0x2u /* embed 52-bit field metadata */
-#define ZFP_HEADER_MODE   0x4u /* embed 12- or 64-bit compression mode */
-#define ZFP_HEADER_FULL   0x7u /* embed all of the above */
-
-/* field metadata indeterminate state and error code */
-#define ZFP_META_NULL (UINT64C(-1))
-
-/* number of bits per header entry */
-#define ZFP_MAGIC_BITS       32 /* number of magic word bits */
-#define ZFP_META_BITS        52 /* number of field metadata bits */
-#define ZFP_MODE_SHORT_BITS  12 /* number of mode bits in short format */
-#define ZFP_MODE_LONG_BITS   64 /* number of mode bits in long format */
-#define ZFP_HEADER_MAX_BITS 148 /* max number of header bits */
-#define ZFP_MODE_SHORT_MAX  ((1u << ZFP_MODE_SHORT_BITS) - 2)
-
-/* types ------------------------------------------------------------------- */
-
-/* execution policy */
-typedef enum {
-  zfp_exec_serial = 0, /* serial execution (default) */
-  zfp_exec_omp    = 1, /* OpenMP multi-threaded execution */
-  zfp_exec_cuda   = 2  /* CUDA parallel execution */
-} zfp_exec_policy;
-
-/* OpenMP execution parameters */
-typedef struct {
-  uint threads;    /* number of requested threads */
-  uint chunk_size; /* number of blocks per chunk (1D only) */
-} zfp_exec_params_omp;
-
-/* execution parameters */
-typedef union {
-  zfp_exec_params_omp omp; /* OpenMP parameters */
-} zfp_exec_params;
-
-typedef struct {
-  zfp_exec_policy policy; /* execution policy (serial, omp, ...) */
-  zfp_exec_params params; /* execution parameters */
-} zfp_execution;
-
-/* compressed stream; use accessors to get/set members */
-typedef struct {
-  uint minbits;       /* minimum number of bits to store per block */
-  uint maxbits;       /* maximum number of bits to store per block */
-  uint maxprec;       /* maximum number of bit planes to store */
-  int minexp;         /* minimum floating point bit plane number to store */
-  bitstream* stream;  /* compressed bit stream */
-  zfp_execution exec; /* execution policy and parameters */
-} zfp_stream;
-
-/* compression mode */
-typedef enum {
-  zfp_mode_null            = 0, /* an invalid configuration of the 4 params */
-  zfp_mode_expert          = 1, /* expert mode (4 params set manually) */
-  zfp_mode_fixed_rate      = 2, /* fixed rate mode */
-  zfp_mode_fixed_precision = 3, /* fixed precision mode */
-  zfp_mode_fixed_accuracy  = 4, /* fixed accuracy mode */
-  zfp_mode_reversible      = 5  /* reversible (lossless) mode */
-} zfp_mode;
-
-/* scalar type */
-typedef enum {
-  zfp_type_none   = 0, /* unspecified type */
-  zfp_type_int32  = 1, /* 32-bit signed integer */
-  zfp_type_int64  = 2, /* 64-bit signed integer */
-  zfp_type_float  = 3, /* single precision floating point */
-  zfp_type_double = 4  /* double precision floating point */
-} zfp_type;
-
-/* uncompressed array; use accessors to get/set members */
-typedef struct {
-  zfp_type type;       /* scalar type (e.g. int32, double) */
-  uint nx, ny, nz, nw; /* sizes (zero for unused dimensions) */
-  int sx, sy, sz, sw;  /* strides (zero for contiguous array a[nw][nz][ny][nx]) */
-  void* data;          /* pointer to array data */
-} zfp_field;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* public data ------------------------------------------------------------- */
-
-extern_ const uint zfp_codec_version;         /* codec version ZFP_CODEC */
-extern_ const uint zfp_library_version;       /* library version ZFP_VERSION */
-extern_ const char* const zfp_version_string; /* verbose version string */
-
-/* high-level API: utility functions --------------------------------------- */
-
-size_t          /* byte size of scalar type */
-zfp_type_size(
-  zfp_type type /* scalar type */
-);
-
-/* high-level API: compressed stream construction/destruction -------------- */
-
-/* open compressed stream and associate with bit stream */
-zfp_stream*         /* allocated compressed stream */
-zfp_stream_open(
-  bitstream* stream /* bit stream to read from and write to (may be NULL) */
-);
-
-/* close and deallocate compressed stream (does not affect bit stream) */
-void
-zfp_stream_close(
-  zfp_stream* stream /* compressed stream */
-);
-
-/* high-level API: compressed stream inspectors ---------------------------- */
-
-/* bit stream associated with compressed stream */
-bitstream*                 /* bit stream associated with compressed stream */
-zfp_stream_bit_stream(
-  const zfp_stream* stream /* compressed stream */
-);
-
-/* returns enum of compression mode */
-zfp_mode                   /* enum for compression mode */
-zfp_stream_compression_mode(
-  const zfp_stream* stream /* compressed stream */
-);
-
-/* get all compression parameters in a compact representation */
-uint64                     /* 12- or 64-bit encoding of parameters */
-zfp_stream_mode(
-  const zfp_stream* stream /* compressed stream */
-);
-
-/* get all compression parameters (pointers may be NULL) */
-void
-zfp_stream_params(
-  const zfp_stream* stream, /* compressed stream */
-  uint* minbits,            /* minimum number of bits per 4^d block */
-  uint* maxbits,            /* maximum number of bits per 4^d block */
-  uint* maxprec,            /* maximum precision (# bit planes coded) */
-  int* minexp               /* minimum base-2 exponent; error <= 2^minexp */
-);
-
-/* byte size of sequentially compressed stream (call after compression) */
-size_t                     /* actual number of bytes of compressed storage */
-zfp_stream_compressed_size(
-  const zfp_stream* stream /* compressed stream */
-);
-
-/* conservative estimate of compressed size in bytes */
-size_t                      /* maximum number of bytes of compressed storage */
-zfp_stream_maximum_size(
-  const zfp_stream* stream, /* compressed stream */
-  const zfp_field* field    /* array to compress */
-);
-
-/* high-level API: initialization of compressed stream parameters ---------- */
-
-/* rewind bit stream to beginning for compression or decompression */
-void
-zfp_stream_rewind(
-  zfp_stream* stream /* compressed bit stream */
-);
-
-/* associate bit stream with compressed stream */
-void
-zfp_stream_set_bit_stream(
-  zfp_stream* stream, /* compressed stream */
-  bitstream* bs       /* bit stream to read from and write to */
-);
-
-/* enable reversible (lossless) compression */
-void
-zfp_stream_set_reversible(
-  zfp_stream* stream /* compressed stream */
-);
-
-/* set size in compressed bits/scalar (fixed-rate mode) */
-double                /* actual rate in compressed bits/scalar */
-zfp_stream_set_rate(
-  zfp_stream* stream, /* compressed stream */
-  double rate,        /* desired rate in compressed bits/scalar */
-  zfp_type type,      /* scalar type to compress */
-  uint dims,          /* array dimensionality (1, 2, 3, or 4) */
-  int wra             /* nonzero if write random access is needed */
-);
-
-/* set precision in uncompressed bits/scalar (fixed-precision mode) */
-uint                  /* actual precision */
-zfp_stream_set_precision(
-  zfp_stream* stream, /* compressed stream */
-  uint precision      /* desired precision in uncompressed bits/scalar */
-);
-
-/* set accuracy as absolute error tolerance (fixed-accuracy mode) */
-double                /* actual error tolerance */
-zfp_stream_set_accuracy(
-  zfp_stream* stream, /* compressed stream */
-  double tolerance    /* desired error tolerance */
-);
-
-/* set parameters from compact encoding; leaves stream intact on failure */
-zfp_mode              /* compression mode or zfp_mode_null upon failure */
-zfp_stream_set_mode(
-  zfp_stream* stream, /* compressed stream */
-  uint64 mode         /* 12- or 64-bit encoding of parameters */
-);
-
-/* set all parameters (expert mode); leaves stream intact on failure */
-int                   /* nonzero upon success */
-zfp_stream_set_params(
-  zfp_stream* stream, /* compressed stream */
-  uint minbits,       /* minimum number of bits per 4^d block */
-  uint maxbits,       /* maximum number of bits per 4^d block */
-  uint maxprec,       /* maximum precision (# bit planes coded) */
-  int minexp          /* minimum base-2 exponent; error <= 2^minexp */
-);
-
-/* high-level API: execution policy ---------------------------------------- */
-
-/* current execution policy */
-zfp_exec_policy
-zfp_stream_execution(
-  const zfp_stream* stream /* compressed stream */
-);
-
-/* number of OpenMP threads to use */
-uint                       /* number of threads (0 for default) */
-zfp_stream_omp_threads(
-  const zfp_stream* stream /* compressed stream */
-);
-
-/* number of blocks per OpenMP chunk (1D only) */
-uint                       /* number of blocks per chunk (0 for default) */
-zfp_stream_omp_chunk_size(
-  const zfp_stream* stream /* compressed stream */
-);
-
-/* set execution policy */
-int                      /* nonzero upon success */
-zfp_stream_set_execution(
-  zfp_stream* stream,    /* compressed stream */
-  zfp_exec_policy policy /* execution policy */
-);
-
-/* set OpenMP execution policy and number of threads */
-int                   /* nonzero upon success */
-zfp_stream_set_omp_threads(
-  zfp_stream* stream, /* compressed stream */
-  uint threads        /* number of OpenMP threads to use (0 for default) */
-);
-
-/* set OpenMP execution policy and number of blocks per chunk (1D only) */
-int                   /* nonzero upon success */
-zfp_stream_set_omp_chunk_size(
-  zfp_stream* stream, /* compressed stream */
-  uint chunk_size     /* number of blocks per chunk (0 for default) */
-);
-
-/* high-level API: uncompressed array construction/destruction ------------- */
-
-/* allocate field struct */
-zfp_field* /* pointer to default initialized field */
-zfp_field_alloc();
-
-/* allocate metadata for 1D field f[nx] */
-zfp_field*       /* allocated field metadata */
-zfp_field_1d(
-  void* pointer, /* pointer to uncompressed scalars (may be NULL) */
-  zfp_type type, /* scalar type */
-  uint nx        /* number of scalars */
-);
-
-/* allocate metadata for 2D field f[ny][nx] */
-zfp_field*       /* allocated field metadata */
-zfp_field_2d(
-  void* pointer, /* pointer to uncompressed scalars (may be NULL) */
-  zfp_type type, /* scalar type */
-  uint nx,       /* number of scalars in x dimension */
-  uint ny        /* number of scalars in y dimension */
-);
-
-/* allocate metadata for 3D field f[nz][ny][nx] */
-zfp_field*       /* allocated field metadata */
-zfp_field_3d(
-  void* pointer, /* pointer to uncompressed scalars (may be NULL) */
-  zfp_type type, /* scalar type */
-  uint nx,       /* number of scalars in x dimension */
-  uint ny,       /* number of scalars in y dimension */
-  uint nz        /* number of scalars in z dimension */
-);
-
-/* allocate metadata for 4D field f[nw][nz][ny][nx] */
-zfp_field*       /* allocated field metadata */
-zfp_field_4d(
-  void* pointer, /* pointer to uncompressed scalars (may be NULL) */
-  zfp_type type, /* scalar type */
-  uint nx,       /* number of scalars in x dimension */
-  uint ny,       /* number of scalars in y dimension */
-  uint nz,       /* number of scalars in z dimension */
-  uint nw        /* number of scalars in w dimension */
-);
-
-/* deallocate field metadata */
-void
-zfp_field_free(
-  zfp_field* field /* field metadata */
-);
-
-/* high-level API: uncompressed array inspectors --------------------------- */
-
-/* pointer to first scalar in field */
-void*                    /* array pointer */
-zfp_field_pointer(
-  const zfp_field* field /* field metadata */
-);
-
-/* field scalar type */
-zfp_type                 /* scalar type */
-zfp_field_type(
-  const zfp_field* field /* field metadata */
-);
-
-/* precision of field scalar type */
-uint                     /* scalar type precision in number of bits */
-zfp_field_precision(
-  const zfp_field* field /* field metadata */
-);
-
-/* field dimensionality (1, 2, or 3) */
-uint                     /* number of dimensions */
-zfp_field_dimensionality(
-  const zfp_field* field /* field metadata */
-);
-
-/* field size in number of scalars */
-size_t                    /* total number of scalars */
-zfp_field_size(
-  const zfp_field* field, /* field metadata */
-  uint* size              /* number of scalars per dimension (may be NULL) */
-);
-
-/* field strides per dimension */
-int                       /* zero if array is contiguous */
-zfp_field_stride(
-  const zfp_field* field, /* field metadata */
-  int* stride             /* stride in scalars per dimension (may be NULL) */
-);
-
-/* field scalar type and dimensions */
-uint64                   /* compact 52-bit encoding of metadata */
-zfp_field_metadata(
-  const zfp_field* field /* field metadata */
-);
-
-/* high-level API: uncompressed array specification ------------------------ */
-
-/* set pointer to first scalar in field */
-void
-zfp_field_set_pointer(
-  zfp_field* field, /* field metadata */
-  void* pointer     /* pointer to first scalar */
-);
-
-/* set field scalar type */
-zfp_type            /* actual scalar type */
-zfp_field_set_type(
-  zfp_field* field, /* field metadata */
-  zfp_type type     /* desired scalar type */
-);
-
-/* set 1D field size */
-void
-zfp_field_set_size_1d(
-  zfp_field* field, /* field metadata */
-  uint nx           /* number of scalars */
-);
-
-/* set 2D field size */
-void
-zfp_field_set_size_2d(
-  zfp_field* field, /* field metadata */
-  uint nx,          /* number of scalars in x dimension */
-  uint ny           /* number of scalars in y dimension */
-);
-
-/* set 3D field size */
-void
-zfp_field_set_size_3d(
-  zfp_field* field, /* field metadata */
-  uint nx,          /* number of scalars in x dimension */
-  uint ny,          /* number of scalars in y dimension */
-  uint nz           /* number of scalars in z dimension */
-);
-
-/* set 4D field size */
-void
-zfp_field_set_size_4d(
-  zfp_field* field, /* field metadata */
-  uint nx,          /* number of scalars in x dimension */
-  uint ny,          /* number of scalars in y dimension */
-  uint nz,          /* number of scalars in z dimension */
-  uint nw           /* number of scalars in w dimension */
-);
-
-/* set 1D field stride in number of scalars */
-void
-zfp_field_set_stride_1d(
-  zfp_field* field, /* field metadata */
-  int sx            /* stride in number of scalars: &f[1] - &f[0] */
-);
-
-/* set 2D field strides in number of scalars */
-void
-zfp_field_set_stride_2d(
-  zfp_field* field, /* field metadata */
-  int sx,           /* stride in x dimension: &f[0][1] - &f[0][0] */
-  int sy            /* stride in y dimension: &f[1][0] - &f[0][0] */
-);
-
-/* set 3D field strides in number of scalars */
-void
-zfp_field_set_stride_3d(
-  zfp_field* field, /* field metadata */
-  int sx,           /* stride in x dimension: &f[0][0][1] - &f[0][0][0] */
-  int sy,           /* stride in y dimension: &f[0][1][0] - &f[0][0][0] */
-  int sz            /* stride in z dimension: &f[1][0][0] - &f[0][0][0] */
-);
-
-/* set 4D field strides in number of scalars */
-void
-zfp_field_set_stride_4d(
-  zfp_field* field, /* field metadata */
-  int sx,           /* stride in x dimension: &f[0][0][0][1] - &f[0][0][0][0] */
-  int sy,           /* stride in y dimension: &f[0][0][1][0] - &f[0][0][0][0] */
-  int sz,           /* stride in z dimension: &f[0][1][0][0] - &f[0][0][0][0] */
-  int sw            /* stride in w dimension: &f[1][0][0][0] - &f[0][0][0][0] */
-);
-
-/* set field scalar type and dimensions */
-int                 /* nonzero upon success */
-zfp_field_set_metadata(
-  zfp_field* field, /* field metadata */
-  uint64 meta       /* compact 52-bit encoding of metadata */
-);
-
-/* high-level API: compression and decompression --------------------------- */
-
-/* compress entire field (nonzero return value upon success) */
-size_t                   /* cumulative number of bytes of compressed storage */
-zfp_compress(
-  zfp_stream* stream,    /* compressed stream */
-  const zfp_field* field /* field metadata */
-);
-
-/* decompress entire field (nonzero return value upon success) */
-size_t                /* cumulative number of bytes of compressed storage */
-zfp_decompress(
-  zfp_stream* stream, /* compressed stream */
-  zfp_field* field    /* field metadata */
-);
-
-/* write compression parameters and field metadata (optional) */
-size_t                    /* number of bits written or zero upon failure */
-zfp_write_header(
-  zfp_stream* stream,     /* compressed stream */
-  const zfp_field* field, /* field metadata */
-  uint mask               /* information to write */
-);
-
-/* read compression parameters and field metadata when previously written */
-size_t                /* number of bits read or zero upon failure */
-zfp_read_header(
-  zfp_stream* stream, /* compressed stream */
-  zfp_field* field,   /* field metadata */
-  uint mask           /* information to read */
-);
-
-/* low-level API: stream manipulation -------------------------------------- */
-
-/* flush bit stream--must be called after last encode call or between seeks */
-size_t
-zfp_stream_flush(
-  zfp_stream* stream /* compressed bit stream */
-);
-
-/* align bit stream on next word boundary (decoding analogy to flush) */
-size_t
-zfp_stream_align(
-  zfp_stream* stream /* compressed bit stream */
-);
-
-/* low-level API: encoder -------------------------------------------------- */
-
-/*
-The functions below all compress either a complete contiguous d-dimensional
-block of 4^d scalars or a complete or partial block assembled from a strided
-array.  In the latter case, p points to the first scalar; (nx, ny, nz) specify
-the size of the block, with 1 <= nx, ny, nz <= 4; and (sx, sy, sz) specify the
-strides, i.e. the number of scalars to advance to get to the next scalar along
-each dimension.  The functions return the number of bits of compressed storage
-needed for the compressed block.
-*/
-
-/* encode 1D contiguous block of 4 values */
-uint zfp_encode_block_int32_1(zfp_stream* stream, const int32* block);
-uint zfp_encode_block_int64_1(zfp_stream* stream, const int64* block);
-uint zfp_encode_block_float_1(zfp_stream* stream, const float* block);
-uint zfp_encode_block_double_1(zfp_stream* stream, const double* block);
-
-/* encode 1D complete or partial block from strided array */
-uint zfp_encode_block_strided_int32_1(zfp_stream* stream, const int32* p, int sx);
-uint zfp_encode_block_strided_int64_1(zfp_stream* stream, const int64* p, int sx);
-uint zfp_encode_block_strided_float_1(zfp_stream* stream, const float* p, int sx);
-uint zfp_encode_block_strided_double_1(zfp_stream* stream, const double* p, int sx);
-uint zfp_encode_partial_block_strided_int32_1(zfp_stream* stream, const int32* p, uint nx, int sx);
-uint zfp_encode_partial_block_strided_int64_1(zfp_stream* stream, const int64* p, uint nx, int sx);
-uint zfp_encode_partial_block_strided_float_1(zfp_stream* stream, const float* p, uint nx, int sx);
-uint zfp_encode_partial_block_strided_double_1(zfp_stream* stream, const double* p, uint nx, int sx);
-
-/* encode 2D contiguous block of 4x4 values */
-uint zfp_encode_block_int32_2(zfp_stream* stream, const int32* block);
-uint zfp_encode_block_int64_2(zfp_stream* stream, const int64* block);
-uint zfp_encode_block_float_2(zfp_stream* stream, const float* block);
-uint zfp_encode_block_double_2(zfp_stream* stream, const double* block);
-
-/* encode 2D complete or partial block from strided array */
-uint zfp_encode_partial_block_strided_int32_2(zfp_stream* stream, const int32* p, uint nx, uint ny, int sx, int sy);
-uint zfp_encode_partial_block_strided_int64_2(zfp_stream* stream, const int64* p, uint nx, uint ny, int sx, int sy);
-uint zfp_encode_partial_block_strided_float_2(zfp_stream* stream, const float* p, uint nx, uint ny, int sx, int sy);
-uint zfp_encode_partial_block_strided_double_2(zfp_stream* stream, const double* p, uint nx, uint ny, int sx, int sy);
-uint zfp_encode_block_strided_int32_2(zfp_stream* stream, const int32* p, int sx, int sy);
-uint zfp_encode_block_strided_int64_2(zfp_stream* stream, const int64* p, int sx, int sy);
-uint zfp_encode_block_strided_float_2(zfp_stream* stream, const float* p, int sx, int sy);
-uint zfp_encode_block_strided_double_2(zfp_stream* stream, const double* p, int sx, int sy);
-
-/* encode 3D contiguous block of 4x4x4 values */
-uint zfp_encode_block_int32_3(zfp_stream* stream, const int32* block);
-uint zfp_encode_block_int64_3(zfp_stream* stream, const int64* block);
-uint zfp_encode_block_float_3(zfp_stream* stream, const float* block);
-uint zfp_encode_block_double_3(zfp_stream* stream, const double* block);
-
-/* encode 3D complete or partial block from strided array */
-uint zfp_encode_block_strided_int32_3(zfp_stream* stream, const int32* p, int sx, int sy, int sz);
-uint zfp_encode_block_strided_int64_3(zfp_stream* stream, const int64* p, int sx, int sy, int sz);
-uint zfp_encode_block_strided_float_3(zfp_stream* stream, const float* p, int sx, int sy, int sz);
-uint zfp_encode_block_strided_double_3(zfp_stream* stream, const double* p, int sx, int sy, int sz);
-uint zfp_encode_partial_block_strided_int32_3(zfp_stream* stream, const int32* p, uint nx, uint ny, uint nz, int sx, int sy, int sz);
-uint zfp_encode_partial_block_strided_int64_3(zfp_stream* stream, const int64* p, uint nx, uint ny, uint nz, int sx, int sy, int sz);
-uint zfp_encode_partial_block_strided_float_3(zfp_stream* stream, const float* p, uint nx, uint ny, uint nz, int sx, int sy, int sz);
-uint zfp_encode_partial_block_strided_double_3(zfp_stream* stream, const double* p, uint nx, uint ny, uint nz, int sx, int sy, int sz);
-
-/* encode 4D contiguous block of 4x4x4x4 values */
-uint zfp_encode_block_int32_4(zfp_stream* stream, const int32* block);
-uint zfp_encode_block_int64_4(zfp_stream* stream, const int64* block);
-uint zfp_encode_block_float_4(zfp_stream* stream, const float* block);
-uint zfp_encode_block_double_4(zfp_stream* stream, const double* block);
-
-/* encode 4D complete or partial block from strided array */
-uint zfp_encode_block_strided_int32_4(zfp_stream* stream, const int32* p, int sx, int sy, int sz, int sw);
-uint zfp_encode_block_strided_int64_4(zfp_stream* stream, const int64* p, int sx, int sy, int sz, int sw);
-uint zfp_encode_block_strided_float_4(zfp_stream* stream, const float* p, int sx, int sy, int sz, int sw);
-uint zfp_encode_block_strided_double_4(zfp_stream* stream, const double* p, int sx, int sy, int sz, int sw);
-uint zfp_encode_partial_block_strided_int32_4(zfp_stream* stream, const int32* p, uint nx, uint ny, uint nz, uint nw, int sx, int sy, int sz, int sw);
-uint zfp_encode_partial_block_strided_int64_4(zfp_stream* stream, const int64* p, uint nx, uint ny, uint nz, uint nw, int sx, int sy, int sz, int sw);
-uint zfp_encode_partial_block_strided_float_4(zfp_stream* stream, const float* p, uint nx, uint ny, uint nz, uint nw, int sx, int sy, int sz, int sw);
-uint zfp_encode_partial_block_strided_double_4(zfp_stream* stream, const double* p, uint nx, uint ny, uint nz, uint nw, int sx, int sy, int sz, int sw);
-
-/* low-level API: decoder -------------------------------------------------- */
-
-/*
-Each function below decompresses a single block and returns the number of bits
-of compressed storage consumed.  See corresponding encoder functions above for
-further details.
-*/
-
-/* decode 1D contiguous block of 4 values */
-uint zfp_decode_block_int32_1(zfp_stream* stream, int32* block);
-uint zfp_decode_block_int64_1(zfp_stream* stream, int64* block);
-uint zfp_decode_block_float_1(zfp_stream* stream, float* block);
-uint zfp_decode_block_double_1(zfp_stream* stream, double* block);
-
-/* decode 1D complete or partial block from strided array */
-uint zfp_decode_block_strided_int32_1(zfp_stream* stream, int32* p, int sx);
-uint zfp_decode_block_strided_int64_1(zfp_stream* stream, int64* p, int sx);
-uint zfp_decode_block_strided_float_1(zfp_stream* stream, float* p, int sx);
-uint zfp_decode_block_strided_double_1(zfp_stream* stream, double* p, int sx);
-uint zfp_decode_partial_block_strided_int32_1(zfp_stream* stream, int32* p, uint nx, int sx);
-uint zfp_decode_partial_block_strided_int64_1(zfp_stream* stream, int64* p, uint nx, int sx);
-uint zfp_decode_partial_block_strided_float_1(zfp_stream* stream, float* p, uint nx, int sx);
-uint zfp_decode_partial_block_strided_double_1(zfp_stream* stream, double* p, uint nx, int sx);
-
-/* decode 2D contiguous block of 4x4 values */
-uint zfp_decode_block_int32_2(zfp_stream* stream, int32* block);
-uint zfp_decode_block_int64_2(zfp_stream* stream, int64* block);
-uint zfp_decode_block_float_2(zfp_stream* stream, float* block);
-uint zfp_decode_block_double_2(zfp_stream* stream, double* block);
-
-/* decode 2D complete or partial block from strided array */
-uint zfp_decode_block_strided_int32_2(zfp_stream* stream, int32* p, int sx, int sy);
-uint zfp_decode_block_strided_int64_2(zfp_stream* stream, int64* p, int sx, int sy);
-uint zfp_decode_block_strided_float_2(zfp_stream* stream, float* p, int sx, int sy);
-uint zfp_decode_block_strided_double_2(zfp_stream* stream, double* p, int sx, int sy);
-uint zfp_decode_partial_block_strided_int32_2(zfp_stream* stream, int32* p, uint nx, uint ny, int sx, int sy);
-uint zfp_decode_partial_block_strided_int64_2(zfp_stream* stream, int64* p, uint nx, uint ny, int sx, int sy);
-uint zfp_decode_partial_block_strided_float_2(zfp_stream* stream, float* p, uint nx, uint ny, int sx, int sy);
-uint zfp_decode_partial_block_strided_double_2(zfp_stream* stream, double* p, uint nx, uint ny, int sx, int sy);
-
-/* decode 3D contiguous block of 4x4x4 values */
-uint zfp_decode_block_int32_3(zfp_stream* stream, int32* block);
-uint zfp_decode_block_int64_3(zfp_stream* stream, int64* block);
-uint zfp_decode_block_float_3(zfp_stream* stream, float* block);
-uint zfp_decode_block_double_3(zfp_stream* stream, double* block);
-
-/* decode 3D complete or partial block from strided array */
-uint zfp_decode_block_strided_int32_3(zfp_stream* stream, int32* p, int sx, int sy, int sz);
-uint zfp_decode_block_strided_int64_3(zfp_stream* stream, int64* p, int sx, int sy, int sz);
-uint zfp_decode_block_strided_float_3(zfp_stream* stream, float* p, int sx, int sy, int sz);
-uint zfp_decode_block_strided_double_3(zfp_stream* stream, double* p, int sx, int sy, int sz);
-uint zfp_decode_partial_block_strided_int32_3(zfp_stream* stream, int32* p, uint nx, uint ny, uint nz, int sx, int sy, int sz);
-uint zfp_decode_partial_block_strided_int64_3(zfp_stream* stream, int64* p, uint nx, uint ny, uint nz, int sx, int sy, int sz);
-uint zfp_decode_partial_block_strided_float_3(zfp_stream* stream, float* p, uint nx, uint ny, uint nz, int sx, int sy, int sz);
-uint zfp_decode_partial_block_strided_double_3(zfp_stream* stream, double* p, uint nx, uint ny, uint nz, int sx, int sy, int sz);
-
-/* decode 4D contiguous block of 4x4x4x4 values */
-uint zfp_decode_block_int32_4(zfp_stream* stream, int32* block);
-uint zfp_decode_block_int64_4(zfp_stream* stream, int64* block);
-uint zfp_decode_block_float_4(zfp_stream* stream, float* block);
-uint zfp_decode_block_double_4(zfp_stream* stream, double* block);
-
-/* decode 4D complete or partial block from strided array */
-uint zfp_decode_block_strided_int32_4(zfp_stream* stream, int32* p, int sx, int sy, int sz, int sw);
-uint zfp_decode_block_strided_int64_4(zfp_stream* stream, int64* p, int sx, int sy, int sz, int sw);
-uint zfp_decode_block_strided_float_4(zfp_stream* stream, float* p, int sx, int sy, int sz, int sw);
-uint zfp_decode_block_strided_double_4(zfp_stream* stream, double* p, int sx, int sy, int sz, int sw);
-uint zfp_decode_partial_block_strided_int32_4(zfp_stream* stream, int32* p, uint nx, uint ny, uint nz, uint nw, int sx, int sy, int sz, int sw);
-uint zfp_decode_partial_block_strided_int64_4(zfp_stream* stream, int64* p, uint nx, uint ny, uint nz, uint nw, int sx, int sy, int sz, int sw);
-uint zfp_decode_partial_block_strided_float_4(zfp_stream* stream, float* p, uint nx, uint ny, uint nz, uint nw, int sx, int sy, int sz, int sw);
-uint zfp_decode_partial_block_strided_double_4(zfp_stream* stream, double* p, uint nx, uint ny, uint nz, uint nw, int sx, int sy, int sz, int sw);
-
-/* low-level API: utility functions ---------------------------------------- */
-
-/* convert dims-dimensional contiguous block to 32-bit integer type */
-void zfp_promote_int8_to_int32(int32* oblock, const int8* iblock, uint dims);
-void zfp_promote_uint8_to_int32(int32* oblock, const uint8* iblock, uint dims);
-void zfp_promote_int16_to_int32(int32* oblock, const int16* iblock, uint dims);
-void zfp_promote_uint16_to_int32(int32* oblock, const uint16* iblock, uint dims);
-
-/* convert dims-dimensional contiguous block from 32-bit integer type */
-void zfp_demote_int32_to_int8(int8* oblock, const int32* iblock, uint dims);
-void zfp_demote_int32_to_uint8(uint8* oblock, const int32* iblock, uint dims);
-void zfp_demote_int32_to_int16(int16* oblock, const int32* iblock, uint dims);
-void zfp_demote_int32_to_uint16(uint16* oblock, const int32* iblock, uint dims);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/cache.h b/ThirdParty/zfp/vtkzfp/include/zfp/cache.h
deleted file mode 100644
index 3630910a08c98a4830cc3f9a872bfee6a9deedcc..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/cache.h
+++ /dev/null
@@ -1,261 +0,0 @@
-#ifndef ZFP_CACHE_H
-#define ZFP_CACHE_H
-
-#include "memory.h"
-
-#ifdef ZFP_WITH_CACHE_PROFILE
-  // maintain stats on hit and miss rates
-  #include <iostream>
-#endif
-
-namespace zfp {
-
-// direct-mapped or two-way skew-associative write-back cache
-template <class Line>
-class Cache {
-public:
-  // cache line index (zero is reserved for unused lines)
-  typedef uint Index;
-
-  // cache tag containing line meta data
-  class Tag {
-  public:
-    Tag() : x(0) {}
-
-    Tag(Index x, bool d) : x(2 * x + d) {}
-
-    // cache line index
-    Index index() const { return x >> 1; }
-
-    // is line dirty?
-    bool dirty() const { return x & 1; }
-
-    // is line used?
-    bool used() const { return x != 0; }
-
-    // mark line as dirty
-    void mark() { x |= 1u; }
-
-    // mark line as unused
-    void clear() { x = 0; }
-
-  protected:
-    Index x;
-  };
-
-  // sequential iterator for looping over cache lines
-  class const_iterator {
-  public:
-    friend class Cache;
-    class Pair {
-    public:
-      Pair(Line* l, Tag t) : line(l), tag(t) {}
-      Line* line;
-      Tag tag;
-    };
-    const_iterator& operator++()
-    {
-      advance();
-      return *this;
-    }
-    const_iterator operator++(int)
-    {
-      const_iterator iter = *this;
-      advance();
-      return iter;
-    }
-    const Pair& operator*() const { return pair; }
-    const Pair* operator->() const { return &pair; }
-    operator const void*() const { return pair.line ? this : 0; }
-
-  protected:
-    const_iterator(Cache* cache) : c(cache), pair(cache->line, cache->tag[0])
-    {
-      if (!pair.tag.used())
-        advance();
-    }
-    void advance()
-    {
-      if (pair.line) {
-        uint i;
-        for (i = uint(pair.line - c->line) + 1; i <= c->mask && !c->tag[i].used(); i++);
-        pair = (i <= c->mask ? Pair(c->line + i, c->tag[i]) : Pair(0, Tag()));
-      }
-    }
-    Cache* c;
-    Pair pair;
-  };
-
-  // allocate cache with at least minsize lines
-  Cache(uint minsize = 0) : tag(0), line(0)
-  {
-    resize(minsize);
-#ifdef ZFP_WITH_CACHE_PROFILE
-    std::cerr << "cache lines=" << mask + 1 << std::endl;
-    hit[0][0] = hit[1][0] = miss[0] = back[0] = 0;
-    hit[0][1] = hit[1][1] = miss[1] = back[1] = 0;
-#endif
-  }
-
-  // copy constructor--performs a deep copy
-  Cache(const Cache& c) : tag(0), line(0)
-  {
-    deep_copy(c);
-  }
-
-  // destructor
-  ~Cache()
-  {
-    zfp::deallocate_aligned(tag);
-    zfp::deallocate_aligned(line);
-#ifdef ZFP_WITH_CACHE_PROFILE
-    std::cerr << "cache R1=" << hit[0][0] << " R2=" << hit[1][0] << " RM=" << miss[0] << " RB=" << back[0]
-              <<      " W1=" << hit[0][1] << " W2=" << hit[1][1] << " WM=" << miss[1] << " WB=" << back[1] << std::endl;
-#endif
-  }
-
-  // assignment operator--performs a deep copy
-  Cache& operator=(const Cache& c)
-  {
-    if (this != &c)
-      deep_copy(c);
-    return *this;
-  }
-
-  // cache size in number of lines
-  uint size() const { return mask + 1; }
-
-  // change cache size to at least minsize lines (all contents will be lost)
-  void resize(uint minsize)
-  {
-    for (mask = minsize ? minsize - 1 : 1; mask & (mask + 1); mask |= mask + 1);
-    zfp::reallocate_aligned(tag, ((size_t)mask + 1) * sizeof(Tag), 0x100);
-    zfp::reallocate_aligned(line, ((size_t)mask + 1) * sizeof(Line), 0x100);
-    clear();
-  }
-
-  // look up cache line #x and return pointer to it if in the cache;
-  // otherwise return null
-  const Line* lookup(Index x) const
-  {
-    uint i = primary(x);
-    if (tag[i].index() == x)
-      return line + i;
-#ifdef ZFP_WITH_CACHE_TWOWAY
-    uint j = secondary(x);
-    if (tag[j].index() == x)
-      return line + j;
-#endif
-    return 0;
-  }
-
-  // look up cache line #x and set ptr to where x is or should be stored;
-  // if the returned tag does not match x, then the caller must implement
-  // write-back (if the line is in use) and then fetch the requested line
-  Tag access(Line*& ptr, Index x, bool write)
-  {
-    uint i = primary(x);
-    if (tag[i].index() == x) {
-      ptr = line + i;
-      if (write)
-        tag[i].mark();
-#ifdef ZFP_WITH_CACHE_PROFILE
-      hit[0][write]++;
-#endif
-      return tag[i];
-    }
-#ifdef ZFP_WITH_CACHE_TWOWAY
-    uint j = secondary(x);
-    if (tag[j].index() == x) {
-      ptr = line + j;
-      if (write)
-        tag[j].mark();
-#ifdef ZFP_WITH_CACHE_PROFILE
-      hit[1][write]++;
-#endif
-      return tag[j];
-    }
-    // cache line not found; prefer primary and not dirty slots
-    i = tag[j].used() && (!tag[i].dirty() || tag[j].dirty()) ? i : j;
-#endif
-    ptr = line + i;
-    Tag t = tag[i];
-    tag[i] = Tag(x, write);
-#ifdef ZFP_WITH_CACHE_PROFILE
-    miss[write]++;
-    if (tag[i].dirty())
-      back[write]++;
-#endif
-    return t;
-  }
-
-  // clear cache without writing back
-  void clear()
-  {
-    for (uint i = 0; i <= mask; i++)
-      tag[i].clear();
-  }
-
-  // flush cache line
-  void flush(const Line* l)
-  {
-    uint i = uint(l - line);
-    tag[i].clear();
-  }
-
-  // return iterator to first cache line
-  const_iterator first() { return const_iterator(this); }
-
-protected:
-  // perform a deep copy
-  void deep_copy(const Cache& c)
-  {
-    mask = c.mask;
-    zfp::clone_aligned(tag, c.tag, mask + 1, 0x100u);
-    zfp::clone_aligned(line, c.line, mask + 1, 0x100u);
-#ifdef ZFP_WITH_CACHE_PROFILE
-    hit[0][0] = c.hit[0][0];
-    hit[0][1] = c.hit[0][1];
-    hit[1][0] = c.hit[1][0];
-    hit[1][1] = c.hit[1][1];
-    miss[0] = c.miss[0];
-    miss[1] = c.miss[1];
-    back[0] = c.back[0];
-    back[1] = c.back[1];
-#endif
-  }
-
-  uint primary(Index x) const { return x & mask; }
-  uint secondary(Index x) const
-  {
-#ifdef ZFP_WITH_CACHE_FAST_HASH
-    // max entropy hash for 26- to 16-bit mapping (not full avalanche)
-    x -= x <<  7;
-    x ^= x >> 16;
-    x -= x <<  3;
-#else
-    // Jenkins hash; see http://burtleburtle.net/bob/hash/integer.html
-    x -= x <<  6;
-    x ^= x >> 17;
-    x -= x <<  9;
-    x ^= x <<  4;
-    x -= x <<  3;
-    x ^= x << 10;
-    x ^= x >> 15;
-#endif
-    return x & mask;
-  }
-
-  Index mask; // cache line mask
-  Tag* tag;   // cache line tags
-  Line* line; // actual decompressed cache lines
-#ifdef ZFP_WITH_CACHE_PROFILE
-  uint64 hit[2][2]; // number of primary/secondary read/write hits
-  uint64 miss[2];   // number of read/write misses
-  uint64 back[2];   // number of write-backs due to read/writes
-#endif
-};
-
-}
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/header.h b/ThirdParty/zfp/vtkzfp/include/zfp/header.h
deleted file mode 100644
index ad6433cf1a5a2591477555ef3ac722a30db6f37a..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/header.h
+++ /dev/null
@@ -1,19 +0,0 @@
-class header {
-public:
-  class exception : public std::runtime_error {
-  public:
-    exception(const std::string& msg) : runtime_error(msg) {}
-
-    virtual ~exception() throw (){}
-  };
-
-  static void concat_sentence(std::string& s, const std::string& msg)
-  {
-    if (!s.empty())
-      s += " ";
-    s += msg;
-  }
-
-  uchar buffer[BITS_TO_BYTES(ZFP_HEADER_SIZE_BITS)];
-};
-
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/headerHelpers.h b/ThirdParty/zfp/vtkzfp/include/zfp/headerHelpers.h
deleted file mode 100644
index ed33816a3e65fe4d424627b29fdb1393e4b22156..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/headerHelpers.h
+++ /dev/null
@@ -1,144 +0,0 @@
-// "Handle" classes useful when throwing exceptions
-
-// buffer holds aligned memory for header, suitable for bitstream r/w (word-aligned)
-class AlignedBufferHandle {
-  public:
-    size_t buffer_size_bytes;
-    // uint64 alignment guarantees bitstream alignment
-    uint64* buffer;
-
-    // can copy a header into aligned buffer
-    AlignedBufferHandle(const zfp::array::header* h = 0) {
-      size_t num_64bit_entries = DIV_ROUND_UP(ZFP_HEADER_SIZE_BITS, CHAR_BIT * sizeof(uint64));
-      buffer = new uint64[num_64bit_entries];
-      buffer_size_bytes = num_64bit_entries * sizeof(uint64);
-
-      if (h)
-        memcpy(buffer, h->buffer, BITS_TO_BYTES(ZFP_HEADER_SIZE_BITS));
-    }
-
-    ~AlignedBufferHandle() {
-      delete[] buffer;
-    }
-
-    void copy_to_header(zfp::array::header* h) {
-      memcpy(h, buffer, BITS_TO_BYTES(ZFP_HEADER_SIZE_BITS));
-    }
-};
-
-// redirect zfp_stream->bitstream to header while object remains in scope
-class DualBitstreamHandle {
-  public:
-    bitstream* old_bs;
-    bitstream* new_bs;
-    zfp_stream* zfp;
-
-    DualBitstreamHandle(zfp_stream* zfp, AlignedBufferHandle& abh) :
-      zfp(zfp)
-    {
-      old_bs = zfp_stream_bit_stream(zfp);
-      new_bs = stream_open(abh.buffer, abh.buffer_size_bytes);
-
-      stream_rewind(new_bs);
-      zfp_stream_set_bit_stream(zfp, new_bs);
-    }
-
-    ~DualBitstreamHandle() {
-      zfp_stream_set_bit_stream(zfp, old_bs);
-      stream_close(new_bs);
-    }
-};
-
-class ZfpFieldHandle {
-  public:
-    zfp_field* field;
-
-    ZfpFieldHandle() {
-      field = zfp_field_alloc();
-    }
-
-    ZfpFieldHandle(zfp_type type, int nx, int ny, int nz) {
-      field = zfp_field_3d(0, type, nx, ny, nz);
-    }
-
-    ~ZfpFieldHandle() {
-      zfp_field_free(field);
-    }
-};
-
-class ZfpStreamHandle {
-  public:
-    bitstream* bs;
-    zfp_stream* stream;
-
-    ZfpStreamHandle(AlignedBufferHandle& abh) {
-      bs = stream_open(abh.buffer, abh.buffer_size_bytes);
-      stream = zfp_stream_open(bs);
-    }
-
-    ~ZfpStreamHandle() {
-      zfp_stream_close(stream);
-      stream_close(bs);
-    }
-};
-
-// verify buffer is large enough, with what header describes
-static bool is_valid_buffer_size(const zfp_stream* stream, uint nx, uint ny, uint nz, size_t expected_buffer_size_bytes)
-{
-  uint mx = ((std::max(nx, 1u)) + 3) / 4;
-  uint my = ((std::max(ny, 1u)) + 3) / 4;
-  uint mz = ((std::max(nz, 1u)) + 3) / 4;
-  size_t blocks = (size_t)mx * (size_t)my * (size_t)mz;
-  // no rounding because fixed-rate wra implies rate is multiple of word size
-  size_t described_buffer_size_bytes = blocks * stream->maxbits / CHAR_BIT;
-
-  return expected_buffer_size_bytes >= described_buffer_size_bytes;
-}
-
-static void read_header_contents(const zfp::array::header& header, size_t expected_buffer_size_bytes, uint& dims, zfp_type& type, double& rate, uint n[4])
-{
-  // create zfp_stream and zfp_field structs to call C API zfp_read_header()
-  AlignedBufferHandle abh;
-  memcpy(abh.buffer, header.buffer, BITS_TO_BYTES(ZFP_HEADER_SIZE_BITS));
-
-  ZfpStreamHandle zsh(abh);
-  ZfpFieldHandle zfh;
-
-  if (!zfp_read_header(zsh.stream, zfh.field, ZFP_HEADER_FULL))
-    throw zfp::array::header::exception("Invalid ZFP header.");
-
-  // gather metadata
-  dims = zfp_field_dimensionality(zfh.field);
-  type = zfp_field_type(zfh.field);
-
-  uint num_block_entries = 1u << (2 * dims);
-  rate = (double)zsh.stream->maxbits / num_block_entries;
-
-  zfp_field_size(zfh.field, n);
-
-  // validate header
-  std::string err_msg = "";
-  verify_header_contents(zsh.stream, zfh.field, err_msg);
-
-  if (!err_msg.empty())
-    throw zfp::array::header::exception(err_msg);
-
-  if (expected_buffer_size_bytes && !is_valid_buffer_size(zsh.stream, zfh.field->nx, zfh.field->ny, zfh.field->nz, expected_buffer_size_bytes))
-    throw zfp::array::header::exception("ZFP header expects a longer buffer than what was passed in.");
-}
-
-// verifies metadata on zfp_stream and zfp_field describe a valid compressed array
-static void verify_header_contents(const zfp_stream* stream, const zfp_field* field, std::string& err_msg)
-{
-  // verify read-header contents
-  zfp_type type = zfp_field_type(field);
-  if (type != zfp_type_float && type != zfp_type_double)
-    zfp::array::header::concat_sentence(err_msg, "ZFP compressed arrays do not yet support scalar types beyond floats and doubles.");
-
-  uint dims = zfp_field_dimensionality(field);
-  if (dims < 1 || dims > 3)
-    zfp::array::header::concat_sentence(err_msg, "ZFP compressed arrays do not yet support dimensionalities beyond 1, 2, and 3.");
-
-  if (zfp_stream_compression_mode(stream) != zfp_mode_fixed_rate)
-    zfp::array::header::concat_sentence(err_msg, "ZFP header specified a non fixed-rate mode, unsupported by this object.");
-}
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/iterator1.h b/ThirdParty/zfp/vtkzfp/include/zfp/iterator1.h
deleted file mode 100644
index 310e8e2dd397072fa2f49a5c7519c23cb49ef625..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/iterator1.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// random access iterator that visits 1D array block by block; this class is nested within zfp::array1
-class iterator {
-public:
-  // typedefs for STL compatibility
-  typedef Scalar value_type;
-  typedef ptrdiff_t difference_type;
-  typedef typename array1::reference reference;
-  typedef typename array1::pointer pointer;
-  typedef std::random_access_iterator_tag iterator_category;
-
-  iterator() : ref(0, 0) {}
-  iterator operator=(const iterator& it) { ref.array = it.ref.array; ref.i = it.ref.i; return *this; }
-  reference operator*() const { return ref; }
-  reference operator[](difference_type d) const { return *operator+(d); }
-  iterator& operator++() { increment(); return *this; }
-  iterator& operator--() { decrement(); return *this; }
-  iterator operator++(int) { iterator it = *this; increment(); return it; }
-  iterator operator--(int) { iterator it = *this; decrement(); return it; }
-  iterator operator+=(difference_type d) { ref.i += d; return *this; }
-  iterator operator-=(difference_type d) { ref.i -= d; return *this; }
-  iterator operator+(difference_type d) const { return iterator(ref.array, ref.i + d); }
-  iterator operator-(difference_type d) const { return iterator(ref.array, ref.i - d); }
-  difference_type operator-(const iterator& it) const { return static_cast<difference_type>(ref.i) - static_cast<difference_type>(it.ref.i); }
-  bool operator==(const iterator& it) const { return ref.array == it.ref.array && ref.i == it.ref.i; }
-  bool operator!=(const iterator& it) const { return !operator==(it); }
-  bool operator<=(const iterator& it) const { return ref.array == it.ref.array && ref.i <= it.ref.i; }
-  bool operator>=(const iterator& it) const { return ref.array == it.ref.array && ref.i >= it.ref.i; }
-  bool operator<(const iterator& it) const { return !operator>=(it); }
-  bool operator>(const iterator& it) const { return !operator<=(it); }
-  uint i() const { return ref.i; }
-
-protected:
-  friend class array1;
-  explicit iterator(array1* array, uint i) : ref(array, i) {}
-  void increment() { ref.i++; }
-  void decrement() { ref.i--; }
-  reference ref;
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/iterator2.h b/ThirdParty/zfp/vtkzfp/include/zfp/iterator2.h
deleted file mode 100644
index 03052c4e6806a8b2dd09d04dd346f9504a9aeddd..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/iterator2.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// forward iterator that visits 2D array block by block; this class is nested within zfp::array2
-class iterator {
-public:
-  // typedefs for STL compatibility
-  typedef Scalar value_type;
-  typedef ptrdiff_t difference_type;
-  typedef typename array2::reference reference;
-  typedef typename array2::pointer pointer;
-  typedef std::forward_iterator_tag iterator_category;
-
-  iterator() : ref(0, 0, 0) {}
-  iterator operator=(const iterator& it) { ref.array = it.ref.array; ref.i = it.ref.i; ref.j = it.ref.j; return *this; }
-  reference operator*() const { return ref; }
-  iterator& operator++() { increment(); return *this; }
-  iterator operator++(int) { iterator it = *this; increment(); return it; }
-  bool operator==(const iterator& it) const { return ref.array == it.ref.array && ref.i == it.ref.i && ref.j == it.ref.j; }
-  bool operator!=(const iterator& it) const { return !operator==(it); }
-  uint i() const { return ref.i; }
-  uint j() const { return ref.j; }
-
-protected:
-  friend class array2;
-  explicit iterator(array2* array, uint i, uint j) : ref(array, i, j) {}
-  void increment()
-  {
-    ref.i++;
-    if (!(ref.i & 3u) || ref.i == ref.array->nx) {
-      ref.i = (ref.i - 1) & ~3u;
-      ref.j++;
-      if (!(ref.j & 3u) || ref.j == ref.array->ny) {
-        ref.j = (ref.j - 1) & ~3u;
-        // done with block; advance to next
-        if ((ref.i += 4) >= ref.array->nx) {
-          ref.i = 0;
-          if ((ref.j += 4) >= ref.array->ny)
-            ref.j = ref.array->ny;
-        }
-      }
-    }
-  }
-  reference ref;
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/iterator3.h b/ThirdParty/zfp/vtkzfp/include/zfp/iterator3.h
deleted file mode 100644
index 3889fc1cacdcd4c87d07930e391bc60ba94baa1b..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/iterator3.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// forward iterator that visits 3D array block by block; this class is nested within zfp::array3
-class iterator {
-public:
-  // typedefs for STL compatibility
-  typedef Scalar value_type;
-  typedef ptrdiff_t difference_type;
-  typedef typename array3::reference reference;
-  typedef typename array3::pointer pointer;
-  typedef std::forward_iterator_tag iterator_category;
-
-  iterator() : ref(0, 0, 0, 0) {}
-  iterator operator=(const iterator& it) { ref.array = it.ref.array; ref.i = it.ref.i; ref.j = it.ref.j; ref.k = it.ref.k; return *this; }
-  reference operator*() const { return ref; }
-  iterator& operator++() { increment(); return *this; }
-  iterator operator++(int) { iterator it = *this; increment(); return it; }
-  bool operator==(const iterator& it) const { return ref.array == it.ref.array && ref.i == it.ref.i && ref.j == it.ref.j && ref.k == it.ref.k; }
-  bool operator!=(const iterator& it) const { return !operator==(it); }
-  uint i() const { return ref.i; }
-  uint j() const { return ref.j; }
-  uint k() const { return ref.k; }
-
-protected:
-  friend class array3;
-  explicit iterator(array3* array, uint i, uint j, uint k) : ref(array, i, j, k) {}
-  void increment()
-  {
-    ref.i++;
-    if (!(ref.i & 3u) || ref.i == ref.array->nx) {
-      ref.i = (ref.i - 1) & ~3u;
-      ref.j++;
-      if (!(ref.j & 3u) || ref.j == ref.array->ny) {
-        ref.j = (ref.j - 1) & ~3u;
-        ref.k++;
-        if (!(ref.k & 3u) || ref.k == ref.array->nz) {
-          ref.k = (ref.k - 1) & ~3u;
-          // done with block; advance to next
-          if ((ref.i += 4) >= ref.array->nx) {
-            ref.i = 0;
-            if ((ref.j += 4) >= ref.array->ny) {
-              ref.j = 0;
-              if ((ref.k += 4) >= ref.array->nz)
-                ref.k = ref.array->nz;
-            }
-          }
-        }
-      }
-    }
-  }
-  reference ref;
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/macros.h b/ThirdParty/zfp/vtkzfp/include/zfp/macros.h
deleted file mode 100644
index be3655c701356db28da52af3ee63bf2a13615b7e..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/macros.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#ifndef ZFP_MACROS_H
-#define ZFP_MACROS_H
-
-#define MIN(x, y) ((x) < (y) ? (x) : (y))
-#define MAX(x, y) ((x) > (y) ? (x) : (y))
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/memory.h b/ThirdParty/zfp/vtkzfp/include/zfp/memory.h
deleted file mode 100644
index 852559da3c8d7df6ded47ffd77f51a926d3c3d8f..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/memory.h
+++ /dev/null
@@ -1,145 +0,0 @@
-#ifndef ZFP_MEMORY_H
-#define ZFP_MEMORY_H
-
-#ifdef _WIN32
-extern "C" {
-  #ifdef __MINGW32__
-  #include <x86intrin.h>
-  #endif
-
-  #include <malloc.h>
-}
-#endif
-
-#include <algorithm>
-#include <cstdlib>
-#include "zfp/types.h"
-
-#define unused_(x) ((void)(x))
-
-namespace zfp {
-
-// allocate size bytes
-inline void*
-allocate(size_t size)
-{
-  return new uchar[size];
-}
-
-// allocate size bytes with alignment
-inline void*
-allocate_aligned(size_t size, size_t alignment)
-{
-  void* ptr;
-  bool is_mem_failed = false;
-
-#ifdef ZFP_WITH_ALIGNED_ALLOC
-  #ifdef __INTEL_COMPILER
-  ptr = _mm_malloc(size, alignment);
-
-  #elif defined(__MINGW32__)
-  ptr = __mingw_aligned_malloc(size, alignment);
-
-  #elif defined(_WIN32)
-  ptr = _aligned_malloc(size, alignment);
-
-  #elif (_POSIX_C_SOURCE >= 200112L) || (_XOPEN_SOURCE >= 600) || defined(__MACH__)
-  is_mem_failed = posix_memalign(&ptr, alignment, size);
-
-  #else
-  unused_(alignment);
-  ptr = malloc(size);
-
-  #endif
-
-#else
-  unused_(alignment);
-  ptr = malloc(size);
-
-#endif
-
-  if (is_mem_failed || (ptr == NULL))
-    throw std::bad_alloc();
-
-  return ptr;
-}
-
-// deallocate memory pointed to by ptr
-template <typename T>
-inline void
-deallocate(T* ptr)
-{
-  delete[] ptr;
-}
-
-template <typename T>
-inline void
-deallocate_aligned(T* ptr)
-{
-#ifdef ZFP_WITH_ALIGNED_ALLOC
-  if (ptr)
-  #ifdef __INTEL_COMPILER
-    _mm_free(ptr);
-  #elif defined(__MINGW32__)
-    __mingw_aligned_free(ptr);
-  #elif defined(_WIN32)
-    _aligned_free(ptr);
-  #else
-    free(ptr);
-  #endif
-
-#else
-  if (ptr)
-    free(ptr);
-#endif
-}
-
-// reallocate size bytes
-template <typename T>
-inline void
-reallocate(T*& ptr, size_t size)
-{
-  zfp::deallocate(ptr);
-  ptr = static_cast<T*>(zfp::allocate(size));
-}
-
-template <typename T>
-inline void
-reallocate_aligned(T*& ptr, size_t size, size_t alignment)
-{
-  zfp::deallocate_aligned(ptr);
-  ptr = static_cast<T*>(zfp::allocate_aligned(size, alignment));
-}
-
-// clone array 'T src[count]'
-template <typename T>
-inline void
-clone(T*& dst, const T* src, size_t count)
-{
-  zfp::deallocate(dst);
-  if (src) {
-    dst = static_cast<T*>(zfp::allocate(count * sizeof(T)));
-    std::copy(src, src + count, dst);
-  }
-  else
-    dst = 0;
-}
-
-template <typename T>
-inline void
-clone_aligned(T*& dst, const T* src, size_t count, size_t alignment)
-{
-  zfp::deallocate_aligned(dst);
-  if (src) {
-    dst = static_cast<T*>(zfp::allocate_aligned(count * sizeof(T), alignment));
-    std::copy(src, src + count, dst);
-  }
-  else
-    dst = 0;
-}
-
-}
-
-#undef unused_
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/pointer1.h b/ThirdParty/zfp/vtkzfp/include/zfp/pointer1.h
deleted file mode 100644
index f58557c0df368b5672164ad61c268b6bcdc02b21..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/pointer1.h
+++ /dev/null
@@ -1,30 +0,0 @@
-// pointer to a 1D array element; this class is nested within zfp::array1
-class pointer {
-public:
-  pointer() : ref(0, 0) {}
-  pointer operator=(const pointer& p) { ref.array = p.ref.array; ref.i = p.ref.i; return *this; }
-  reference operator*() const { return ref; }
-  reference operator[](ptrdiff_t d) const { return *operator+(d); }
-  pointer& operator++() { increment(); return *this; }
-  pointer& operator--() { decrement(); return *this; }
-  pointer operator++(int) { pointer p = *this; increment(); return p; }
-  pointer operator--(int) { pointer p = *this; decrement(); return p; }
-  pointer operator+=(ptrdiff_t d) { ref.i += d; return *this; }
-  pointer operator-=(ptrdiff_t d) { ref.i -= d; return *this; }
-  pointer operator+(ptrdiff_t d) const { pointer p = *this; p += d; return p; }
-  pointer operator-(ptrdiff_t d) const { pointer p = *this; p -= d; return p; }
-  ptrdiff_t operator-(const pointer& p) const { return index() - p.index(); }
-  bool operator==(const pointer& p) const { return ref.array == p.ref.array && ref.i == p.ref.i; }
-  bool operator!=(const pointer& p) const { return !operator==(p); }
-
-protected:
-  friend class array1;
-  friend class reference;
-  explicit pointer(reference r) : ref(r) {}
-  explicit pointer(array1* array, uint i) : ref(array, i) {}
-  ptrdiff_t index() const { return ref.i; }
-  void set(ptrdiff_t index) { ref.i = index; }
-  void increment() { ref.i++; }
-  void decrement() { ref.i--; }
-  reference ref;
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/pointer2.h b/ThirdParty/zfp/vtkzfp/include/zfp/pointer2.h
deleted file mode 100644
index dcdb518fb90072a282dccb4f61a36d5d289667b2..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/pointer2.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// pointer to a 2D array element; this class is nested within zfp::array2
-class pointer {
-public:
-  pointer() : ref(0, 0, 0) {}
-  pointer operator=(const pointer& p) { ref.array = p.ref.array; ref.i = p.ref.i; ref.j = p.ref.j; return *this; }
-  reference operator*() const { return ref; }
-  reference operator[](ptrdiff_t d) const { return *operator+(d); }
-  pointer& operator++() { increment(); return *this; }
-  pointer& operator--() { decrement(); return *this; }
-  pointer operator++(int) { pointer p = *this; increment(); return p; }
-  pointer operator--(int) { pointer p = *this; decrement(); return p; }
-  pointer operator+=(ptrdiff_t d) { set(index() + d); return *this; }
-  pointer operator-=(ptrdiff_t d) { set(index() - d); return *this; }
-  pointer operator+(ptrdiff_t d) const { pointer p = *this; p += d; return p; }
-  pointer operator-(ptrdiff_t d) const { pointer p = *this; p -= d; return p; }
-  ptrdiff_t operator-(const pointer& p) const { return index() - p.index(); }
-  bool operator==(const pointer& p) const { return ref.array == p.ref.array && ref.i == p.ref.i && ref.j == p.ref.j; }
-  bool operator!=(const pointer& p) const { return !operator==(p); }
-
-protected:
-  friend class array2;
-  friend class reference;
-  explicit pointer(reference r) : ref(r) {}
-  explicit pointer(array2* array, uint i, uint j) : ref(array, i, j) {}
-  ptrdiff_t index() const { return ref.i + ref.array->nx * ref.j; }
-  void set(ptrdiff_t index) { ref.array->ij(ref.i, ref.j, index); }
-  void increment()
-  {
-    if (++ref.i == ref.array->nx) {
-      ref.i = 0;
-      ref.j++;
-    }
-  }
-  void decrement()
-  {
-    if (!ref.i--) {
-      ref.i = ref.array->nx - 1;
-      ref.j--;
-    }
-  }
-  reference ref;
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/pointer3.h b/ThirdParty/zfp/vtkzfp/include/zfp/pointer3.h
deleted file mode 100644
index 091af6044b45cf96db396edc44a3ee7bd5b2c5c6..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/pointer3.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// pointer to a 3D array element; this class is nested within zfp::array3
-class pointer {
-public:
-  pointer() : ref(0, 0, 0, 0) {}
-  pointer operator=(const pointer& p) { ref.array = p.ref.array; ref.i = p.ref.i; ref.j = p.ref.j; ref.k = p.ref.k; return *this; }
-  reference operator*() const { return ref; }
-  reference operator[](ptrdiff_t d) const { return *operator+(d); }
-  pointer& operator++() { increment(); return *this; }
-  pointer& operator--() { decrement(); return *this; }
-  pointer operator++(int) { pointer p = *this; increment(); return p; }
-  pointer operator--(int) { pointer p = *this; decrement(); return p; }
-  pointer operator+=(ptrdiff_t d) { set(index() + d); return *this; }
-  pointer operator-=(ptrdiff_t d) { set(index() - d); return *this; }
-  pointer operator+(ptrdiff_t d) const { pointer p = *this; p += d; return p; }
-  pointer operator-(ptrdiff_t d) const { pointer p = *this; p -= d; return p; }
-  ptrdiff_t operator-(const pointer& p) const { return index() - p.index(); }
-  bool operator==(const pointer& p) const { return ref.array == p.ref.array && ref.i == p.ref.i && ref.j == p.ref.j && ref.k == p.ref.k; }
-  bool operator!=(const pointer& p) const { return !operator==(p); }
-
-protected:
-  friend class array3;
-  friend class reference;
-  explicit pointer(reference r) : ref(r) {}
-  explicit pointer(array3* array, uint i, uint j, uint k) : ref(array, i, j, k) {}
-  ptrdiff_t index() const { return ref.i + ref.array->nx * (ref.j + ref.array->ny * ref.k); }
-  void set(ptrdiff_t index) { ref.array->ijk(ref.i, ref.j, ref.k, index); }
-  void increment()
-  {
-    if (++ref.i == ref.array->nx) {
-      ref.i = 0;
-      if (++ref.j == ref.array->ny) {
-        ref.j = 0;
-        ref.k++;
-      }
-    }
-  }
-  void decrement()
-  {
-    if (!ref.i--) {
-      ref.i = ref.array->nx - 1;
-      if (!ref.j--) {
-        ref.j = ref.array->ny - 1;
-        ref.k--;
-      }
-    }
-  }
-  reference ref;
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/reference1.h b/ThirdParty/zfp/vtkzfp/include/zfp/reference1.h
deleted file mode 100644
index 99f2e6a67643d0fb47db27ccaccdd418c71cf301..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/reference1.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// reference to a 1D array element; this class is nested within zfp::array1
-class reference {
-public:
-  operator Scalar() const { return array->get(i); }
-  reference operator=(const reference& r) { array->set(i, r.operator Scalar()); return *this; }
-  reference operator=(Scalar val) { array->set(i, val); return *this; }
-  reference operator+=(Scalar val) { array->add(i, val); return *this; }
-  reference operator-=(Scalar val) { array->sub(i, val); return *this; }
-  reference operator*=(Scalar val) { array->mul(i, val); return *this; }
-  reference operator/=(Scalar val) { array->div(i, val); return *this; }
-  pointer operator&() const { return pointer(*this); }
-  // swap two array elements via proxy references
-  friend void swap(reference a, reference b)
-  {
-    Scalar x = a.operator Scalar();
-    Scalar y = b.operator Scalar();
-    b.operator=(x);
-    a.operator=(y);
-  }
-
-protected:
-  friend class array1;
-  friend class iterator;
-  explicit reference(array1* array, uint i) : array(array), i(i) {}
-  array1* array;
-  uint i;
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/reference2.h b/ThirdParty/zfp/vtkzfp/include/zfp/reference2.h
deleted file mode 100644
index 76a0bd3b10158e015203e644a74070159703eed9..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/reference2.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// reference to a 2D array element; this class is nested within zfp::array2
-class reference {
-public:
-  operator Scalar() const { return array->get(i, j); }
-  reference operator=(const reference& r) { array->set(i, j, r.operator Scalar()); return *this; }
-  reference operator=(Scalar val) { array->set(i, j, val); return *this; }
-  reference operator+=(Scalar val) { array->add(i, j, val); return *this; }
-  reference operator-=(Scalar val) { array->sub(i, j, val); return *this; }
-  reference operator*=(Scalar val) { array->mul(i, j, val); return *this; }
-  reference operator/=(Scalar val) { array->div(i, j, val); return *this; }
-  pointer operator&() const { return pointer(*this); }
-  // swap two array elements via proxy references
-  friend void swap(reference a, reference b)
-  {
-    Scalar x = a.operator Scalar();
-    Scalar y = b.operator Scalar();
-    b.operator=(x);
-    a.operator=(y);
-  }
-
-protected:
-  friend class array2;
-  friend class iterator;
-  explicit reference(array2* array, uint i, uint j) : array(array), i(i), j(j) {}
-  array2* array;
-  uint i, j;
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/reference3.h b/ThirdParty/zfp/vtkzfp/include/zfp/reference3.h
deleted file mode 100644
index 91175e18033c1c1a578346bc0c5a0342e646853b..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/reference3.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// reference to a 3D array element; this class is nested within zfp::array3
-class reference {
-public:
-  operator Scalar() const { return array->get(i, j, k); }
-  reference operator=(const reference& r) { array->set(i, j, k, r.operator Scalar()); return *this; }
-  reference operator=(Scalar val) { array->set(i, j, k, val); return *this; }
-  reference operator+=(Scalar val) { array->add(i, j, k, val); return *this; }
-  reference operator-=(Scalar val) { array->sub(i, j, k, val); return *this; }
-  reference operator*=(Scalar val) { array->mul(i, j, k, val); return *this; }
-  reference operator/=(Scalar val) { array->div(i, j, k, val); return *this; }
-  pointer operator&() const { return pointer(*this); }
-  // swap two array elements via proxy references
-  friend void swap(reference a, reference b)
-  {
-    Scalar x = a.operator Scalar();
-    Scalar y = b.operator Scalar();
-    b.operator=(x);
-    a.operator=(y);
-  }
-
-protected:
-  friend class array3;
-  friend class iterator;
-  explicit reference(array3* array, uint i, uint j, uint k) : array(array), i(i), j(j), k(k) {}
-  array3* array;
-  uint i, j, k;
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/system.h b/ThirdParty/zfp/vtkzfp/include/zfp/system.h
deleted file mode 100644
index 5394196482551e342c9f673d2f398469a487cd59..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/system.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#ifndef ZFP_SYSTEM_H
-#define ZFP_SYSTEM_H
-
-#if __STDC_VERSION__ >= 199901L
-  #define restrict_ restrict
-#else
-  #define restrict_
-#endif
-
-/* macros for exporting and importing symbols */
-#ifdef _MSC_VER
-  #define export_ __declspec(dllexport)
-  /* export (import) symbols when ZFP_SOURCE is (is not) defined */
-  #ifdef ZFP_SOURCE
-    #ifdef __cplusplus
-      #define extern_ extern "C" __declspec(dllexport)
-    #else
-      #define extern_ extern     __declspec(dllexport)
-    #endif
-  #else
-    #ifdef __cplusplus
-      #define extern_ extern "C" __declspec(dllimport)
-    #else
-      #define extern_ extern     __declspec(dllimport)
-    #endif
-  #endif
-#else /* !_MSC_VER */
-  #define export_
-  #ifdef __cplusplus
-    #define extern_ extern "C"
-  #else
-    #define extern_ extern
-  #endif
-#endif
-
-#ifdef __GNUC__
-  /* L1 cache line size for alignment purposes */
-  #ifndef ZFP_CACHE_LINE_SIZE
-    #define ZFP_CACHE_LINE_SIZE 0x100
-  #endif
-  #define align_(n) __attribute__((aligned(n)))
-  #define cache_align_(x) x align_(ZFP_CACHE_LINE_SIZE)
-#else
-  #define cache_align_(x) x
-#endif
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/types.h b/ThirdParty/zfp/vtkzfp/include/zfp/types.h
deleted file mode 100644
index f57e1f896617b1dad55addd42ca06a274423dbf6..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/types.h
+++ /dev/null
@@ -1,107 +0,0 @@
-#ifndef ZFP_TYPES_H
-#define ZFP_TYPES_H
-
-typedef unsigned char uchar;
-typedef unsigned short ushort;
-typedef unsigned int uint;
-
-#if __STDC_VERSION__ >= 199901L
-  /* C99: use standard integer types */
-  #include <stdint.h>
-  #include <inttypes.h>
-  #define INT64C(x) INT64_C(x)
-  #define UINT64C(x) UINT64_C(x)
-  #define INT64PRId PRId64
-  #define INT64PRIi PRIi64
-  #define UINT64PRIo PRIo64
-  #define UINT64PRIu PRIu64
-  #define UINT64PRIx PRIx64
-  #define INT64SCNd SCNd64
-  #define INT64SCNi SCNi64
-  #define UINT64SCNo SCNo64
-  #define UINT64SCNu SCNu64
-  #define UINT64SCNx SCNx64
-  typedef int8_t int8;
-  typedef uint8_t uint8;
-  typedef int16_t int16;
-  typedef uint16_t uint16;
-  typedef int32_t int32;
-  typedef uint32_t uint32;
-  typedef int64_t int64;
-  typedef uint64_t uint64;
-#else
-  /* C89: assume common integer types */
-  typedef signed char int8;
-  typedef unsigned char uint8;
-  typedef signed short int16;
-  typedef unsigned short uint16;
-
-  /* assume 32-bit integers (LP64, LLP64) */
-  typedef signed int int32;
-  typedef unsigned int uint32;
-
-  /* determine 64-bit data model */
-  #if defined(_WIN32) || defined(_WIN64)
-    /* assume ILP32 or LLP64 (MSVC, MinGW) */
-    #define ZFP_LLP64 1
-  #else
-    /* assume LP64 (Linux, macOS, ...) */
-    #define ZFP_LP64 1
-  #endif
-
-  /* concatenation for literal suffixes */
-  #define _zfp_cat_(x, y) x ## y
-  #define _zfp_cat(x, y) _zfp_cat_(x, y)
-
-  /* signed 64-bit integers */
-  #if defined(ZFP_INT64) && defined(ZFP_INT64_SUFFIX)
-    #define INT64C(x) _zfp_cat(x, ZFP_INT64_SUFFIX)
-    #define INT64PRId #ZFP_INT64_SUFFIX "d"
-    #define INT64PRIi #ZFP_INT64_SUFFIX "i"
-    typedef ZFP_INT64 int64;
-  #elif ZFP_LP64
-    #define INT64C(x) x ## l
-    #define INT64PRId "ld"
-    #define INT64PRIi "li"
-    typedef signed long int64;
-  #elif ZFP_LLP64
-    #define INT64C(x) x ## ll
-    #define INT64PRId "lld"
-    #define INT64PRIi "lli"
-    typedef signed long long int64;
-  #else
-    #error "unknown 64-bit signed integer type"
-  #endif
-  #define INT64SCNd INT64PRId
-  #define INT64SCNi INT64PRIi
-
-  /* unsigned 64-bit integers */
-  #if defined(ZFP_UINT64) && defined(ZFP_UINT64_SUFFIX)
-    #define UINT64C(x) _zfp_cat(x, ZFP_UINT64_SUFFIX)
-    #ifdef ZFP_INT64_SUFFIX
-      #define UINT64PRIo #ZFP_INT64_SUFFIX "o"
-      #define UINT64PRIu #ZFP_INT64_SUFFIX "u"
-      #define UINT64PRIx #ZFP_INT64_SUFFIX "x"
-    #endif
-    typedef ZFP_UINT64 uint64;
-  #elif ZFP_LP64
-    #define UINT64C(x) x ## ul
-    #define UINT64PRIo "lo"
-    #define UINT64PRIu "lu"
-    #define UINT64PRIx "lx"
-    typedef unsigned long uint64;
-  #elif ZFP_LLP64
-    #define UINT64C(x) x ## ull
-    #define UINT64PRIo "llo"
-    #define UINT64PRIu "llu"
-    #define UINT64PRIx "llx"
-    typedef unsigned long long uint64;
-  #else
-    #error "unknown 64-bit unsigned integer type"
-  #endif
-  #define UINT64SCNo UINT64PRIo
-  #define UINT64SCNu UINT64PRIu
-  #define UINT64SCNx UINT64PRIx
-#endif
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/view1.h b/ThirdParty/zfp/vtkzfp/include/zfp/view1.h
deleted file mode 100644
index 6129ae5ee06431720931c27bbd0d7d6726b5dee3..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/view1.h
+++ /dev/null
@@ -1,291 +0,0 @@
-// 1D array views; these classes are nested within zfp::array1
-
-// abstract view of 1D array (base class)
-class preview {
-public:
-  // rate in bits per value
-  double rate() const { return array->rate(); }
-
-  // dimensions of (sub)array
-  size_t size() const { return size_t(nx); }
-
-  // local to global array index
-  uint global_x(uint i) const { return x + i; }
-
-protected:
-  // construction and assignment--perform shallow copy of (sub)array
-  explicit preview(array1* array) : array(array), x(0), nx(array->nx) {}
-  explicit preview(array1* array, uint x, uint nx) : array(array), x(x), nx(nx) {}
-  preview& operator=(array1* a)
-  {
-    array = a;
-    x = 0;
-    nx = a->nx;
-    return *this;
-  }
-
-  array1* array; // underlying container
-  uint x;        // offset into array
-  uint nx;       // dimensions of subarray
-};
-
-// generic read-only view into a rectangular subset of a 1D array
-class const_view : public preview {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::nx;
-public:
-  // construction--perform shallow copy of (sub)array
-  const_view(array1* array) : preview(array) {}
-  const_view(array1* array, uint x, uint nx) : preview(array, x, nx) {}
-
-  // dimensions of (sub)array
-  uint size_x() const { return nx; }
-
-  // [i] accessor
-  Scalar operator[](uint index) const { return array->get(x + index); }
-
-  // (i) accessor
-  Scalar operator()(uint i) const { return array->get(x + i); }
-};
-
-// generic read-write view into a rectangular subset of a 1D array
-class view : public const_view {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::nx;
-public:
-  // construction--perform shallow copy of (sub)array
-  view(array1* array) : const_view(array) {}
-  view(array1* array, uint x, uint nx) : const_view(array, x, nx) {}
-
-  // [i] accessor from base class
-  using const_view::operator[];
-
-  // (i) accessor from base class
-  using const_view::operator();
-
-  // [i] mutator
-  reference operator[](uint index) { return reference(array, x + index); }
-
-  // (i) mutator
-  reference operator()(uint i) { return reference(array, x + i); }
-};
-
-// thread-safe read-only view of 1D (sub)array with private cache
-class private_const_view : public preview {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::nx;
-public:
-  // construction--perform shallow copy of (sub)array
-  private_const_view(array1* array) :
-    preview(array),
-    cache(array->cache.size())
-  {
-    init();
-  }
-  private_const_view(array1* array, uint x, uint nx) :
-    preview(array, x, nx),
-    cache(array->cache.size())
-  {
-    init();
-  }
-
-  // destructor
-  ~private_const_view()
-  {
-    stream_close(zfp->stream);
-    zfp_stream_close(zfp);
-  }
-
-  // dimensions of (sub)array
-  uint size_x() const { return nx; }
-
-  // cache size in number of bytes
-  size_t cache_size() const { return cache.size() * sizeof(CacheLine); }
-
-  // set minimum cache size in bytes (array dimensions must be known)
-  void set_cache_size(size_t csize)
-  {
-    cache.resize(array->lines(csize, nx));
-  }
-
-  // empty cache without compressing modified cached blocks
-  void clear_cache() const { cache.clear(); }
-
-  // (i) accessor
-  Scalar operator()(uint i) const { return get(x + i); }
-
-protected:
-  // cache line representing one block of decompressed values
-  class CacheLine {
-  public:
-    const Scalar& operator()(uint i) const { return a[index(i)]; }
-    Scalar& operator()(uint i) { return a[index(i)]; }
-    const Scalar* data() const { return a; }
-    Scalar* data() { return a; }
-  protected:
-    static uint index(uint i) { return i & 3u; }
-    Scalar a[4];
-  };
-
-  // copy private data
-  void init()
-  {
-    // copy compressed stream
-    zfp = zfp_stream_open(0);
-    *zfp = *array->zfp;
-    // copy bit stream
-    zfp->stream = stream_clone(array->zfp->stream);
-  }
-
-  // inspector
-  const Scalar& get(uint i) const
-  {
-    const CacheLine* p = line(i);
-    return (*p)(i);
-  }
-
-  // return cache line for i; may require write-back and fetch
-  CacheLine* line(uint i) const
-  {
-    CacheLine* p = 0;
-    uint b = array->block(i);
-    typename Cache<CacheLine>::Tag t = cache.access(p, b + 1, false);
-    uint c = t.index() - 1;
-    // fetch cache line; no writeback possible since view is read-only
-    if (c != b)
-      decode(b, p->data());
-    return p;
-  }
-
-  // decode block with given index
-  void decode(uint index, Scalar* block) const
-  {
-    stream_rseek(zfp->stream, index * array->blkbits);
-    Codec::decode_block_1(zfp, block, array->shape ? array->shape[index] : 0);
-  }
-
-  zfp_stream* zfp;                // stream of compressed blocks
-  mutable Cache<CacheLine> cache; // cache of decompressed blocks
-};
-
-// thread-safe read-write view of private 1D (sub)array
-class private_view : public private_const_view {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::nx;
-  using private_const_view::zfp;
-  using private_const_view::cache;
-  using private_const_view::init;
-  using private_const_view::decode;
-  class view_reference;
-  typedef typename private_const_view::CacheLine CacheLine;
-public:
-  // construction--perform shallow copy of (sub)array
-  private_view(array1* array) : private_const_view(array) {}
-  private_view(array1* array, uint x, uint nx) : private_const_view(array, x, nx) {}
-
-  // partition view into count block-aligned pieces, with 0 <= index < count
-  void partition(uint index, uint count)
-  {
-    partition(x, nx, index, count);
-  }
-
-  // flush cache by compressing all modified cached blocks
-  void flush_cache() const
-  {
-    for (typename Cache<CacheLine>::const_iterator p = cache.first(); p; p++) {
-      if (p->tag.dirty()) {
-        uint b = p->tag.index() - 1;
-        encode(b, p->line->data());
-      }
-      cache.flush(p->line);
-    }
-  }
-
-  // (i) accessor from base class
-  using private_const_view::operator();
-
-  // (i) mutator
-  view_reference operator()(uint i) { return view_reference(this, x + i); }
-
-protected:
-  class view_reference {
-  public:
-    operator Scalar() const { return view->get(i); }
-    view_reference operator=(const view_reference& r) { view->set(i, r.operator Scalar()); return *this; }
-    view_reference operator=(Scalar val) { view->set(i, val); return *this; }
-    view_reference operator+=(Scalar val) { view->add(i, val); return *this; }
-    view_reference operator-=(Scalar val) { view->sub(i, val); return *this; }
-    view_reference operator*=(Scalar val) { view->mul(i, val); return *this; }
-    view_reference operator/=(Scalar val) { view->div(i, val); return *this; }
-    // swap two array elements via proxy references
-    friend void swap(view_reference a, view_reference b)
-    {
-      Scalar x = a.operator Scalar();
-      Scalar y = b.operator Scalar();
-      b.operator=(x);
-      a.operator=(y);
-    }
-
-  protected:
-    friend class private_view;
-    explicit view_reference(private_view* view, uint i) : view(view), i(i) {}
-    private_view* view;
-    uint i;
-  };
-
-  // block-aligned partition of [offset, offset + size): index out of count
-  static void partition(uint& offset, uint& size, uint index, uint count)
-  {
-    uint bmin = offset / 4;
-    uint bmax = (offset + size + 3) / 4;
-    uint xmin = std::max(offset +    0, 4 * (bmin + (bmax - bmin) * (index + 0) / count));
-    uint xmax = std::min(offset + size, 4 * (bmin + (bmax - bmin) * (index + 1) / count));
-    offset = xmin;
-    size = xmax - xmin;
-  }
-
-  // mutator
-  void set(uint i, Scalar val)
-  {
-    CacheLine* p = line(i, true);
-    (*p)(i) = val;
-  }
-
-  // in-place updates
-  void add(uint i, Scalar val) { (*line(i, true))(i) += val; }
-  void sub(uint i, Scalar val) { (*line(i, true))(i) -= val; }
-  void mul(uint i, Scalar val) { (*line(i, true))(i) *= val; }
-  void div(uint i, Scalar val) { (*line(i, true))(i) /= val; }
-
-  // return cache line for i; may require write-back and fetch
-  CacheLine* line(uint i, bool write) const
-  {
-    CacheLine* p = 0;
-    uint b = array->block(i);
-    typename Cache<CacheLine>::Tag t = cache.access(p, b + 1, write);
-    uint c = t.index() - 1;
-    if (c != b) {
-      // write back occupied cache line if it is dirty
-      if (t.dirty())
-        encode(c, p->data());
-      decode(b, p->data());
-    }
-    return p;
-  }
-
-  // encode block with given index
-  void encode(uint index, const Scalar* block) const
-  {
-    stream_wseek(zfp->stream, index * array->blkbits);
-    Codec::encode_block_1(zfp, block, array->shape ? array->shape[index] : 0);
-    stream_flush(zfp->stream);
-  }
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/view2.h b/ThirdParty/zfp/vtkzfp/include/zfp/view2.h
deleted file mode 100644
index fcfdf8cad8f05594ca3963541590eec81f305888..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/view2.h
+++ /dev/null
@@ -1,393 +0,0 @@
-// 2D array views; these classes are nested within zfp::array2
-
-// abstract view of 2D array (base class)
-class preview {
-public:
-  // rate in bits per value
-  double rate() const { return array->rate(); }
-
-  // dimensions of (sub)array
-  size_t size() const { return size_t(nx) * size_t(ny); }
-
-  // local to global array indices
-  uint global_x(uint i) const { return x + i; }
-  uint global_y(uint j) const { return y + j; }
-
-protected:
-  // construction and assignment--perform shallow copy of (sub)array
-  explicit preview(array2* array) : array(array), x(0), y(0), nx(array->nx), ny(array->ny) {}
-  explicit preview(array2* array, uint x, uint y, uint nx, uint ny) : array(array), x(x), y(y), nx(nx), ny(ny) {}
-  preview& operator=(array2* a)
-  {
-    array = a;
-    x = y = 0;
-    nx = a->nx;
-    ny = a->ny;
-    return *this;
-  }
-
-  array2* array; // underlying container
-  uint x, y;     // offset into array
-  uint nx, ny;   // dimensions of subarray
-};
-
-// generic read-only view into a rectangular subset of a 2D array
-class const_view : public preview {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::nx;
-  using preview::ny;
-public:
-  // construction--perform shallow copy of (sub)array
-  const_view(array2* array) : preview(array) {}
-  const_view(array2* array, uint x, uint y, uint nx, uint ny) : preview(array, x, y, nx, ny) {}
-
-  // dimensions of (sub)array
-  uint size_x() const { return nx; }
-  uint size_y() const { return ny; }
-
-  // (i, j) accessor
-  Scalar operator()(uint i, uint j) const { return array->get(x + i, y + j); }
-};
-
-// generic read-write view into a rectangular subset of a 2D array
-class view : public const_view {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::nx;
-  using preview::ny;
-public:
-  // construction--perform shallow copy of (sub)array
-  view(array2* array) : const_view(array) {}
-  view(array2* array, uint x, uint y, uint nx, uint ny) : const_view(array, x, y, nx, ny) {}
-
-  // (i, j) accessor from base class
-  using const_view::operator();
-
-  // (i, j) mutator
-  reference operator()(uint i, uint j) { return reference(array, x + i, y + j); }
-};
-
-// flat view of 2D array (operator[] returns scalar)
-class flat_view : public view {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::nx;
-  using preview::ny;
-public:
-  // construction--perform shallow copy of (sub)array
-  flat_view(array2* array) : view(array) {}
-  flat_view(array2* array, uint x, uint y, uint nx, uint ny) : view(array, x, y, nx, ny) {}
-
-  // convert (i, j) index to flat index
-  uint index(uint i, uint j) const { return i + nx * j; }
-
-  // convert flat index to (i, j) index
-  void ij(uint& i, uint& j, uint index) const
-  {
-    i = index % nx; index /= nx;
-    j = index;
-  }
-
-  // flat index accessors
-  Scalar operator[](uint index) const
-  {
-    uint i, j;
-    ij(i, j, index);
-    return array->get(x + i, y + j);
-  }
-  reference operator[](uint index)
-  {
-    uint i, j;
-    ij(i, j, index);
-    return reference(array, x + i, y + j);
-  }
-};
-
-// forward declaration of friends
-class nested_view1;
-class nested_view2;
-
-// nested view into a 1D rectangular subset of a 2D array
-class nested_view1 : public preview {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::nx;
-  using preview::ny;
-public:
-  // dimensions of (sub)array
-  uint size_x() const { return nx; }
-
-  // [i] accessor and mutator
-  Scalar operator[](uint index) const { return array->get(x + index, y); }
-  reference operator[](uint index) { return reference(array, x + index, y); }
-
-  // (i) accessor and mutator
-  Scalar operator()(uint i) const { return array->get(x + i, y); }
-  reference operator()(uint i) { return reference(array, x + i, y); }
-
-protected:
-  // construction--perform shallow copy of (sub)array
-  friend class nested_view2;
-  explicit nested_view1(array2* array) : preview(array) {}
-  explicit nested_view1(array2* array, uint x, uint y, uint nx, uint ny) : preview(array, x, y, nx, ny) {}
-};
-
-// nested view into a 2D rectangular subset of a 2D array
-class nested_view2 : public preview {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::nx;
-  using preview::ny;
-public:
-  // construction--perform shallow copy of (sub)array
-  nested_view2(array2* array) : preview(array) {}
-  nested_view2(array2* array, uint x, uint y, uint nx, uint ny) : preview(array, x, y, nx, ny) {}
-
-  // dimensions of (sub)array
-  uint size_x() const { return nx; }
-  uint size_y() const { return ny; }
-
-  // 1D view
-  nested_view1 operator[](uint index) const { return nested_view1(array, x, y + index, nx, 1); }
-
-  // (i, j) accessor and mutator
-  Scalar operator()(uint i, uint j) const { return array->get(x + i, y + j); }
-  reference operator()(uint i, uint j) { return reference(array, x + i, y + j); }
-};
-
-typedef nested_view2 nested_view;
-
-// thread-safe read-only view of 2D (sub)array with private cache
-class private_const_view : public preview {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::nx;
-  using preview::ny;
-public:
-  // construction--perform shallow copy of (sub)array
-  private_const_view(array2* array) :
-    preview(array),
-    cache(array->cache.size())
-  {
-    init();
-  }
-  private_const_view(array2* array, uint x, uint y, uint nx, uint ny) :
-    preview(array, x, y, nx, ny),
-    cache(array->cache.size())
-  {
-    init();
-  }
-
-  // destructor
-  ~private_const_view()
-  {
-    stream_close(zfp->stream);
-    zfp_stream_close(zfp);
-  }
-
-  // dimensions of (sub)array
-  uint size_x() const { return nx; }
-  uint size_y() const { return ny; }
-
-  // cache size in number of bytes
-  size_t cache_size() const { return cache.size() * sizeof(CacheLine); }
-
-  // set minimum cache size in bytes (array dimensions must be known)
-  void set_cache_size(size_t csize)
-  {
-    cache.resize(array->lines(csize, nx, ny));
-  }
-
-  // empty cache without compressing modified cached blocks
-  void clear_cache() const { cache.clear(); }
-
-  // (i, j) accessor
-  Scalar operator()(uint i, uint j) const { return get(x + i, y + j); }
-
-protected:
-  // cache line representing one block of decompressed values
-  class CacheLine {
-  public:
-    const Scalar& operator()(uint i, uint j) const { return a[index(i, j)]; }
-    Scalar& operator()(uint i, uint j) { return a[index(i, j)]; }
-    const Scalar* data() const { return a; }
-    Scalar* data() { return a; }
-  protected:
-    static uint index(uint i, uint j) { return (i & 3u) + 4 * (j & 3u); }
-    Scalar a[16];
-  };
-
-  // copy private data
-  void init()
-  {
-    // copy compressed stream
-    zfp = zfp_stream_open(0);
-    *zfp = *array->zfp;
-    // copy bit stream
-    zfp->stream = stream_clone(array->zfp->stream);
-  }
-
-  // inspector
-  const Scalar& get(uint i, uint j) const
-  {
-    const CacheLine* p = line(i, j);
-    return (*p)(i, j);
-  }
-
-  // return cache line for (i, j); may require write-back and fetch
-  CacheLine* line(uint i, uint j) const
-  {
-    CacheLine* p = 0;
-    uint b = array->block(i, j);
-    typename Cache<CacheLine>::Tag t = cache.access(p, b + 1, false);
-    uint c = t.index() - 1;
-    // fetch cache line; no writeback possible since view is read-only
-    if (c != b)
-      decode(b, p->data());
-    return p;
-  }
-
-  // decode block with given index
-  void decode(uint index, Scalar* block) const
-  {
-    stream_rseek(zfp->stream, index * array->blkbits);
-    Codec::decode_block_2(zfp, block, array->shape ? array->shape[index] : 0);
-  }
-
-  zfp_stream* zfp;                // stream of compressed blocks
-  mutable Cache<CacheLine> cache; // cache of decompressed blocks
-};
-
-// thread-safe read-write view of private 2D (sub)array
-class private_view : public private_const_view {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::nx;
-  using preview::ny;
-  using private_const_view::zfp;
-  using private_const_view::cache;
-  using private_const_view::init;
-  using private_const_view::decode;
-  class view_reference;
-  typedef typename private_const_view::CacheLine CacheLine;
-public:
-  // construction--perform shallow copy of (sub)array
-  private_view(array2* array) : private_const_view(array) {}
-  private_view(array2* array, uint x, uint y, uint nx, uint ny) : private_const_view(array, x, y, nx, ny) {}
-
-  // partition view into count block-aligned pieces, with 0 <= index < count
-  void partition(uint index, uint count)
-  {
-    if (nx > ny)
-      partition(x, nx, index, count);
-    else
-      partition(y, ny, index, count);
-  }
-
-  // flush cache by compressing all modified cached blocks
-  void flush_cache() const
-  {
-    for (typename Cache<CacheLine>::const_iterator p = cache.first(); p; p++) {
-      if (p->tag.dirty()) {
-        uint b = p->tag.index() - 1;
-        encode(b, p->line->data());
-      }
-      cache.flush(p->line);
-    }
-  }
-
-  // (i, j) accessor from base class
-  using private_const_view::operator();
-
-  // (i, j) mutator
-  view_reference operator()(uint i, uint j) { return view_reference(this, x + i, y + j); }
-
-protected:
-  class view_reference {
-  public:
-    operator Scalar() const { return view->get(i, j); }
-    view_reference operator=(const view_reference& r) { view->set(i, j, r.operator Scalar()); return *this; }
-    view_reference operator=(Scalar val) { view->set(i, j, val); return *this; }
-    view_reference operator+=(Scalar val) { view->add(i, j, val); return *this; }
-    view_reference operator-=(Scalar val) { view->sub(i, j, val); return *this; }
-    view_reference operator*=(Scalar val) { view->mul(i, j, val); return *this; }
-    view_reference operator/=(Scalar val) { view->div(i, j, val); return *this; }
-    // swap two array elements via proxy references
-    friend void swap(view_reference a, view_reference b)
-    {
-      Scalar x = a.operator Scalar();
-      Scalar y = b.operator Scalar();
-      b.operator=(x);
-      a.operator=(y);
-    }
-
-  protected:
-    friend class private_view;
-    explicit view_reference(private_view* view, uint i, uint j) : view(view), i(i), j(j) {}
-    private_view* view;
-    uint i, j;
-  };
-
-  // block-aligned partition of [offset, offset + size): index out of count
-  static void partition(uint& offset, uint& size, uint index, uint count)
-  {
-    uint bmin = offset / 4;
-    uint bmax = (offset + size + 3) / 4;
-    uint xmin = std::max(offset +    0, 4 * (bmin + (bmax - bmin) * (index + 0) / count));
-    uint xmax = std::min(offset + size, 4 * (bmin + (bmax - bmin) * (index + 1) / count));
-    offset = xmin;
-    size = xmax - xmin;
-  }
-
-  // mutator
-  void set(uint i, uint j, Scalar val)
-  {
-    CacheLine* p = line(i, j, true);
-    (*p)(i, j) = val;
-  }
-
-  // in-place updates
-  void add(uint i, uint j, Scalar val) { (*line(i, j, true))(i, j) += val; }
-  void sub(uint i, uint j, Scalar val) { (*line(i, j, true))(i, j) -= val; }
-  void mul(uint i, uint j, Scalar val) { (*line(i, j, true))(i, j) *= val; }
-  void div(uint i, uint j, Scalar val) { (*line(i, j, true))(i, j) /= val; }
-
-  // return cache line for (i, j); may require write-back and fetch
-  CacheLine* line(uint i, uint j, bool write) const
-  {
-    CacheLine* p = 0;
-    uint b = array->block(i, j);
-    typename Cache<CacheLine>::Tag t = cache.access(p, b + 1, write);
-    uint c = t.index() - 1;
-    if (c != b) {
-      // write back occupied cache line if it is dirty
-      if (t.dirty())
-        encode(c, p->data());
-      decode(b, p->data());
-    }
-    return p;
-  }
-
-  // encode block with given index
-  void encode(uint index, const Scalar* block) const
-  {
-    stream_wseek(zfp->stream, index * array->blkbits);
-    Codec::encode_block_2(zfp, block, array->shape ? array->shape[index] : 0);
-    stream_flush(zfp->stream);
-  }
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfp/view3.h b/ThirdParty/zfp/vtkzfp/include/zfp/view3.h
deleted file mode 100644
index b1bf457fc8a1f144ab67e4fc9f0caf1221eb494a..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfp/view3.h
+++ /dev/null
@@ -1,445 +0,0 @@
-// 3D array views; these classes are nested within zfp::array3
-
-// abstract view of 3D array (base class)
-class preview {
-public:
-  // rate in bits per value
-  double rate() const { return array->rate(); }
-
-  // dimensions of (sub)array
-  size_t size() const { return size_t(nx) * size_t(ny) * size_t(nz); }
-
-  // local to global array indices
-  uint global_x(uint i) const { return x + i; }
-  uint global_y(uint j) const { return y + j; }
-  uint global_z(uint k) const { return z + k; }
-
-protected:
-  // construction and assignment--perform shallow copy of (sub)array
-  explicit preview(array3* array) : array(array), x(0), y(0), z(0), nx(array->nx), ny(array->ny), nz(array->nz) {}
-  explicit preview(array3* array, uint x, uint y, uint z, uint nx, uint ny, uint nz) : array(array), x(x), y(y), z(z), nx(nx), ny(ny), nz(nz) {}
-  preview& operator=(array3* a)
-  {
-    array = a;
-    x = y = z = 0;
-    nx = a->nx;
-    ny = a->ny;
-    nz = a->nz;
-    return *this;
-  }
-
-  array3* array;   // underlying container
-  uint x, y, z;    // offset into array
-  uint nx, ny, nz; // dimensions of subarray
-};
-
-// generic read-only view into a rectangular subset of a 3D array
-class const_view : public preview {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::z;
-  using preview::nx;
-  using preview::ny;
-  using preview::nz;
-public:
-  // construction--perform shallow copy of (sub)array
-  const_view(array3* array) : preview(array) {}
-  const_view(array3* array, uint x, uint y, uint z, uint nx, uint ny, uint nz) : preview(array, x, y, z, nx, ny, nz) {}
-
-  // dimensions of (sub)array
-  uint size_x() const { return nx; }
-  uint size_y() const { return ny; }
-  uint size_z() const { return nz; }
-
-  // (i, j, k) accessor
-  Scalar operator()(uint i, uint j, uint k) const { return array->get(x + i, y + j, z + k); }
-};
-
-// generic read-write view into a rectangular subset of a 3D array
-class view : public const_view {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::z;
-  using preview::nx;
-  using preview::ny;
-  using preview::nz;
-public:
-  // construction--perform shallow copy of (sub)array
-  view(array3* array) : const_view(array) {}
-  view(array3* array, uint x, uint y, uint z, uint nx, uint ny, uint nz) : const_view(array, x, y, z, nx, ny, nz) {}
-
-  // (i, j, k) accessor from base class
-  using const_view::operator();
-
-  // (i, j, k) mutator
-  reference operator()(uint i, uint j, uint k) { return reference(array, x + i, y + j, z + k); }
-};
-
-// flat view of 3D array (operator[] returns scalar)
-class flat_view : public view {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::z;
-  using preview::nx;
-  using preview::ny;
-  using preview::nz;
-public:
-  // construction--perform shallow copy of (sub)array
-  flat_view(array3* array) : view(array) {}
-  flat_view(array3* array, uint x, uint y, uint z, uint nx, uint ny, uint nz) : view(array, x, y, z, nx, ny, nz) {}
-
-  // convert (i, j, k) index to flat index
-  uint index(uint i, uint j, uint k) const { return i + nx * (j + ny * k); }
-
-  // convert flat index to (i, j, k) index
-  void ijk(uint& i, uint& j, uint& k, uint index) const
-  {
-    i = index % nx; index /= nx;
-    j = index % ny; index /= ny;
-    k = index;
-  }
-
-  // flat index accessors
-  Scalar operator[](uint index) const
-  {
-    uint i, j, k;
-    ijk(i, j, k, index);
-    return array->get(x + i, y + j, z + k);
-  }
-  reference operator[](uint index)
-  {
-    uint i, j, k;
-    ijk(i, j, k, index);
-    return reference(array, x + i, y + j, z + k);
-  }
-};
-
-// forward declaration of friends
-class nested_view1;
-class nested_view2;
-class nested_view3;
-
-// nested view into a 1D rectangular subset of a 3D array
-class nested_view1 : public preview {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::z;
-  using preview::nx;
-  using preview::ny;
-  using preview::nz;
-public:
-  // dimensions of (sub)array
-  uint size_x() const { return nx; }
-
-  // [i] accessor and mutator
-  Scalar operator[](uint index) const { return array->get(x + index, y, z); }
-  reference operator[](uint index) { return reference(array, x + index, y, z); }
-
-  // (i) accessor and mutator
-  Scalar operator()(uint i) const { return array->get(x + i, y, z); }
-  reference operator()(uint i) { return reference(array, x + i, y, z); }
-
-protected:
-  // construction--perform shallow copy of (sub)array
-  friend class nested_view2;
-  explicit nested_view1(array3* array) : preview(array) {}
-  explicit nested_view1(array3* array, uint x, uint y, uint z, uint nx, uint ny, uint nz) : preview(array, x, y, z, nx, ny, nz) {}
-};
-
-// nested view into a 2D rectangular subset of a 3D array
-class nested_view2 : public preview {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::z;
-  using preview::nx;
-  using preview::ny;
-  using preview::nz;
-public:
-  // dimensions of (sub)array
-  uint size_x() const { return nx; }
-  uint size_y() const { return ny; }
-
-  // 1D view
-  nested_view1 operator[](uint index) const { return nested_view1(array, x, y + index, z, nx, 1, 1); }
-
-  // (i, j) accessor and mutator
-  Scalar operator()(uint i, uint j) const { return array->get(x + i, y + j, z); }
-  reference operator()(uint i, uint j) { return reference(array, x + i, y + j, z); }
-
-protected:
-  // construction--perform shallow copy of (sub)array
-  friend class nested_view3;
-  explicit nested_view2(array3* array) : preview(array) {}
-  explicit nested_view2(array3* array, uint x, uint y, uint z, uint nx, uint ny, uint nz) : preview(array, x, y, z, nx, ny, nz) {}
-};
-
-// nested view into a 3D rectangular subset of a 3D array
-class nested_view3 : public preview {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::z;
-  using preview::nx;
-  using preview::ny;
-  using preview::nz;
-public:
-  // construction--perform shallow copy of (sub)array
-  nested_view3(array3* array) : preview(array) {}
-  nested_view3(array3* array, uint x, uint y, uint z, uint nx, uint ny, uint nz) : preview(array, x, y, z, nx, ny, nz) {}
-
-  // dimensions of (sub)array
-  uint size_x() const { return nx; }
-  uint size_y() const { return ny; }
-  uint size_z() const { return nz; }
-
-  // 2D view
-  nested_view2 operator[](uint index) const { return nested_view2(array, x, y, z + index, nx, ny, 1); }
-
-  // (i, j, k) accessor and mutator
-  Scalar operator()(uint i, uint j, uint k) const { return array->get(x + i, y + j, z + k); }
-  reference operator()(uint i, uint j, uint k) { return reference(array, x + i, y + j, z + k); }
-};
-
-typedef nested_view3 nested_view;
-
-// thread-safe read-only view of 3D (sub)array with private cache
-class private_const_view : public preview {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::z;
-  using preview::nx;
-  using preview::ny;
-  using preview::nz;
-public:
-  // construction--perform shallow copy of (sub)array
-  private_const_view(array3* array) :
-    preview(array),
-    cache(array->cache.size())
-  {
-    init();
-  }
-  private_const_view(array3* array, uint x, uint y, uint z, uint nx, uint ny, uint nz) :
-    preview(array, x, y, z, nx, ny, nz),
-    cache(array->cache.size())
-  {
-    init();
-  }
-
-  // destructor
-  ~private_const_view()
-  {
-    stream_close(zfp->stream);
-    zfp_stream_close(zfp);
-  }
-
-  // dimensions of (sub)array
-  uint size_x() const { return nx; }
-  uint size_y() const { return ny; }
-  uint size_z() const { return nz; }
-
-  // cache size in number of bytes
-  size_t cache_size() const { return cache.size() * sizeof(CacheLine); }
-
-  // set minimum cache size in bytes (array dimensions must be known)
-  void set_cache_size(size_t csize)
-  {
-    cache.resize(array->lines(csize, nx, ny, nz));
-  }
-
-  // empty cache without compressing modified cached blocks
-  void clear_cache() const { cache.clear(); }
-
-  // (i, j, k) accessor
-  Scalar operator()(uint i, uint j, uint k) const { return get(x + i, y + j, z + k); }
-
-protected:
-  // cache line representing one block of decompressed values
-  class CacheLine {
-  public:
-    const Scalar& operator()(uint i, uint j, uint k) const { return a[index(i, j, k)]; }
-    Scalar& operator()(uint i, uint j, uint k) { return a[index(i, j, k)]; }
-    const Scalar* data() const { return a; }
-    Scalar* data() { return a; }
-  protected:
-    static uint index(uint i, uint j, uint k) { return (i & 3u) + 4 * ((j & 3u) + 4 * (k & 3u)); }
-    Scalar a[64];
-  };
-
-  // copy private data
-  void init()
-  {
-    // copy compressed stream
-    zfp = zfp_stream_open(0);
-    *zfp = *array->zfp;
-    // copy bit stream
-    zfp->stream = stream_clone(array->zfp->stream);
-  }
-
-  // inspector
-  const Scalar& get(uint i, uint j, uint k) const
-  {
-    const CacheLine* p = line(i, j, k);
-    return (*p)(i, j, k);
-  }
-
-  // return cache line for (i, j, k); may require write-back and fetch
-  CacheLine* line(uint i, uint j, uint k) const
-  {
-    CacheLine* p = 0;
-    uint b = array->block(i, j, k);
-    typename Cache<CacheLine>::Tag t = cache.access(p, b + 1, false);
-    uint c = t.index() - 1;
-    // fetch cache line; no writeback possible since view is read-only
-    if (c != b)
-      decode(b, p->data());
-    return p;
-  }
-
-  // decode block with given index
-  void decode(uint index, Scalar* block) const
-  {
-    stream_rseek(zfp->stream, index * array->blkbits);
-    Codec::decode_block_3(zfp, block, array->shape ? array->shape[index] : 0);
-  }
-
-  zfp_stream* zfp;                // stream of compressed blocks
-  mutable Cache<CacheLine> cache; // cache of decompressed blocks
-};
-
-// thread-safe read-write view of private 3D (sub)array
-class private_view : public private_const_view {
-protected:
-  using preview::array;
-  using preview::x;
-  using preview::y;
-  using preview::z;
-  using preview::nx;
-  using preview::ny;
-  using preview::nz;
-  using private_const_view::zfp;
-  using private_const_view::cache;
-  using private_const_view::init;
-  using private_const_view::decode;
-  class view_reference;
-  typedef typename private_const_view::CacheLine CacheLine;
-public:
-  // construction--perform shallow copy of (sub)array
-  private_view(array3* array) : private_const_view(array) {}
-  private_view(array3* array, uint x, uint y, uint z, uint nx, uint ny, uint nz) : private_const_view(array, x, y, z, nx, ny, nz) {}
-
-  // partition view into count block-aligned pieces, with 0 <= index < count
-  void partition(uint index, uint count)
-  {
-    if (nx > std::max(ny, nz))
-      partition(x, nx, index, count);
-    else if (ny > std::max(nx, nz))
-      partition(y, ny, index, count);
-    else
-      partition(z, nz, index, count);
-  }
-
-  // flush cache by compressing all modified cached blocks
-  void flush_cache() const
-  {
-    for (typename Cache<CacheLine>::const_iterator p = cache.first(); p; p++) {
-      if (p->tag.dirty()) {
-        uint b = p->tag.index() - 1;
-        encode(b, p->line->data());
-      }
-      cache.flush(p->line);
-    }
-  }
-
-  // (i, j, k) accessor from base class
-  using private_const_view::operator();
-
-  // (i, j, k) mutator
-  view_reference operator()(uint i, uint j, uint k) { return view_reference(this, x + i, y + j, z + k); }
-
-protected:
-  class view_reference {
-  public:
-    operator Scalar() const { return view->get(i, j, k); }
-    view_reference operator=(const view_reference& r) { view->set(i, j, k, r.operator Scalar()); return *this; }
-    view_reference operator=(Scalar val) { view->set(i, j, k, val); return *this; }
-    view_reference operator+=(Scalar val) { view->add(i, j, k, val); return *this; }
-    view_reference operator-=(Scalar val) { view->sub(i, j, k, val); return *this; }
-    view_reference operator*=(Scalar val) { view->mul(i, j, k, val); return *this; }
-    view_reference operator/=(Scalar val) { view->div(i, j, k, val); return *this; }
-    // swap two array elements via proxy references
-    friend void swap(view_reference a, view_reference b)
-    {
-      Scalar x = a.operator Scalar();
-      Scalar y = b.operator Scalar();
-      b.operator=(x);
-      a.operator=(y);
-    }
-
-  protected:
-    friend class private_view;
-    explicit view_reference(private_view* view, uint i, uint j, uint k) : view(view), i(i), j(j), k(k) {}
-    private_view* view;
-    uint i, j, k;
-  };
-
-  // block-aligned partition of [offset, offset + size): index out of count
-  static void partition(uint& offset, uint& size, uint index, uint count)
-  {
-    uint bmin = offset / 4;
-    uint bmax = (offset + size + 3) / 4;
-    uint xmin = std::max(offset +    0, 4 * (bmin + (bmax - bmin) * (index + 0) / count));
-    uint xmax = std::min(offset + size, 4 * (bmin + (bmax - bmin) * (index + 1) / count));
-    offset = xmin;
-    size = xmax - xmin;
-  }
-
-  // mutator
-  void set(uint i, uint j, uint k, Scalar val)
-  {
-    CacheLine* p = line(i, j, k, true);
-    (*p)(i, j, k) = val;
-  }
-
-  // in-place updates
-  void add(uint i, uint j, uint k, Scalar val) { (*line(i, j, k, true))(i, j, k) += val; }
-  void sub(uint i, uint j, uint k, Scalar val) { (*line(i, j, k, true))(i, j, k) -= val; }
-  void mul(uint i, uint j, uint k, Scalar val) { (*line(i, j, k, true))(i, j, k) *= val; }
-  void div(uint i, uint j, uint k, Scalar val) { (*line(i, j, k, true))(i, j, k) /= val; }
-
-  // return cache line for (i, j, k); may require write-back and fetch
-  CacheLine* line(uint i, uint j, uint k, bool write) const
-  {
-    CacheLine* p = 0;
-    uint b = array->block(i, j, k);
-    typename Cache<CacheLine>::Tag t = cache.access(p, b + 1, write);
-    uint c = t.index() - 1;
-    if (c != b) {
-      // write back occupied cache line if it is dirty
-      if (t.dirty())
-        encode(c, p->data());
-      decode(b, p->data());
-    }
-    return p;
-  }
-
-  // encode block with given index
-  void encode(uint index, const Scalar* block) const
-  {
-    stream_wseek(zfp->stream, index * array->blkbits);
-    Codec::encode_block_3(zfp, block, array->shape ? array->shape[index] : 0);
-    stream_flush(zfp->stream);
-  }
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfparray.h b/ThirdParty/zfp/vtkzfp/include/zfparray.h
deleted file mode 100644
index 2ddbde426f08af5a857fcb8950aa51816b3c8f3b..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfparray.h
+++ /dev/null
@@ -1,286 +0,0 @@
-#ifndef ZFP_ARRAY_H
-#define ZFP_ARRAY_H
-
-#include <algorithm>
-#include <climits>
-#include <cstring>
-#include <stdexcept>
-#include <string>
-
-#include "zfp.h"
-#include "zfp/memory.h"
-
-// all undefined at end
-#define DIV_ROUND_UP(x, y) (((x) + (y) - 1) / (y))
-#define BITS_TO_BYTES(x) DIV_ROUND_UP(x, CHAR_BIT)
-
-#define ZFP_HEADER_SIZE_BITS (ZFP_MAGIC_BITS + ZFP_META_BITS + ZFP_MODE_SHORT_BITS)
-
-namespace zfp {
-
-// abstract base class for compressed array of scalars
-class array {
-public:
-  #include "zfp/header.h"
-
-  static zfp::array* construct(const zfp::array::header& header, const uchar* buffer = 0, size_t buffer_size_bytes = 0);
-
-protected:
-  // default constructor
-  array() :
-    dims(0), type(zfp_type_none),
-    nx(0), ny(0), nz(0),
-    bx(0), by(0), bz(0),
-    blocks(0), blkbits(0),
-    bytes(0), data(0),
-    zfp(0),
-    shape(0)
-  {}
-
-  // generic array with 'dims' dimensions and scalar type 'type'
-  array(uint dims, zfp_type type) :
-    dims(dims), type(type),
-    nx(0), ny(0), nz(0),
-    bx(0), by(0), bz(0),
-    blocks(0), blkbits(0),
-    bytes(0), data(0),
-    zfp(zfp_stream_open(0)),
-    shape(0)
-  {}
-
-  // constructor, from previously-serialized compressed array
-  array(uint dims, zfp_type type, const zfp::array::header& h, size_t expected_buffer_size_bytes) :
-    dims(dims), type(type),
-    nx(0), ny(0), nz(0),
-    bx(0), by(0), bz(0),
-    blocks(0), blkbits(0),
-    bytes(0), data(0),
-    zfp(zfp_stream_open(0)),
-    shape(0)
-  {
-    // read header to populate member variables associated with zfp_stream
-    try {
-      read_from_header(h);
-    } catch (zfp::array::header::exception const &) {
-      zfp_stream_close(zfp);
-      throw;
-    }
-
-    if (expected_buffer_size_bytes && !is_valid_buffer_size(zfp, nx, ny, nz, expected_buffer_size_bytes)) {
-      zfp_stream_close(zfp);
-      throw zfp::array::header::exception("ZFP header expects a longer buffer than what was passed in.");
-    }
-  }
-
-  // copy constructor--performs a deep copy
-  array(const array& a) :
-    data(0),
-    zfp(0),
-    shape(0)
-  {
-    deep_copy(a);
-  }
-
-  // assignment operator--performs a deep copy
-  array& operator=(const array& a)
-  {
-    deep_copy(a);
-    return *this;
-  }
-
-public:
-  // public virtual destructor (can delete array through base class pointer)
-  virtual ~array()
-  {
-    free();
-    zfp_stream_close(zfp);
-  }
-
-  // rate in bits per value
-  double rate() const { return double(blkbits) / block_size(); }
-
-  // set compression rate in bits per value
-  double set_rate(double rate)
-  {
-    rate = zfp_stream_set_rate(zfp, rate, type, dims, 1);
-    blkbits = zfp->maxbits;
-    alloc();
-    return rate;
-  }
-
-  // empty cache without compressing modified cached blocks
-  virtual void clear_cache() const = 0;
-
-  // flush cache by compressing all modified cached blocks
-  virtual void flush_cache() const = 0;
-
-  // number of bytes of compressed data
-  size_t compressed_size() const { return bytes; }
-
-  // pointer to compressed data for read or write access
-  uchar* compressed_data() const
-  {
-    // first write back any modified cached data
-    flush_cache();
-    return data;
-  }
-
-  // dimensionality
-  uint dimensionality() const { return dims; }
-
-  // underlying scalar type
-  zfp_type scalar_type() const { return type; }
-
-  // write header with latest metadata
-  zfp::array::header get_header() const
-  {
-    // intermediate buffer needed (bitstream accesses multiples of wordsize)
-    AlignedBufferHandle abh;
-    DualBitstreamHandle dbh(zfp, abh);
-
-    ZfpFieldHandle zfh(type, nx, ny, nz);
-
-    // avoid long header (alignment issue)
-    if (zfp_stream_mode(zfp) > ZFP_MODE_SHORT_MAX)
-      throw zfp::array::header::exception("ZFP compressed arrays only support short headers at this time.");
-
-    if (!zfp_write_header(zfp, zfh.field, ZFP_HEADER_FULL))
-      throw zfp::array::header::exception("ZFP could not write a header to buffer.");
-    stream_flush(zfp->stream);
-
-    zfp::array::header h;
-    abh.copy_to_header(&h);
-
-    return h;
-  }
-
-private:
-  // private members used when reading/writing headers
-  #include "zfp/headerHelpers.h"
-
-protected:
-  // number of values per block
-  uint block_size() const { return 1u << (2 * dims); }
-
-  // allocate memory for compressed data
-  void alloc(bool clear = true)
-  {
-    bytes = blocks * blkbits / CHAR_BIT;
-    zfp::reallocate_aligned(data, bytes, 0x100u);
-    if (clear)
-      std::fill(data, data + bytes, 0);
-    stream_close(zfp->stream);
-    zfp_stream_set_bit_stream(zfp, stream_open(data, bytes));
-    clear_cache();
-  }
-
-  // free memory associated with compressed data
-  void free()
-  {
-    nx = ny = nz = 0;
-    bx = by = bz = 0;
-    blocks = 0;
-    stream_close(zfp->stream);
-    zfp_stream_set_bit_stream(zfp, 0);
-    bytes = 0;
-    zfp::deallocate_aligned(data);
-    data = 0;
-    zfp::deallocate(shape);
-    shape = 0;
-  }
-
-  // perform a deep copy
-  void deep_copy(const array& a)
-  {
-    // copy metadata
-    dims = a.dims;
-    type = a.type;
-    nx = a.nx;
-    ny = a.ny;
-    nz = a.nz;
-    bx = a.bx;
-    by = a.by;
-    bz = a.bz;
-    blocks = a.blocks;
-    blkbits = a.blkbits;
-    bytes = a.bytes;
-
-    // copy dynamically allocated data
-    zfp::clone_aligned(data, a.data, bytes, 0x100u);
-    if (zfp) {
-      if (zfp->stream)
-        stream_close(zfp->stream);
-      zfp_stream_close(zfp);
-    }
-    zfp = zfp_stream_open(0);
-    *zfp = *a.zfp;
-    zfp_stream_set_bit_stream(zfp, stream_open(data, bytes));
-    zfp::clone(shape, a.shape, blocks);
-  }
-
-  // attempt reading header from zfp::array::header
-  // and verify header contents (throws exceptions upon failure)
-  void read_from_header(const zfp::array::header& h)
-  {
-    // copy header into aligned buffer
-    AlignedBufferHandle abh(&h);
-    DualBitstreamHandle dbh(zfp, abh);
-    ZfpFieldHandle zfh;
-
-    // read header to populate member variables associated with zfp_stream
-    size_t readbits = zfp_read_header(zfp, zfh.field, ZFP_HEADER_FULL);
-    if (!readbits)
-      throw zfp::array::header::exception("Invalid ZFP header.");
-    else if (readbits != ZFP_HEADER_SIZE_BITS)
-      throw zfp::array::header::exception("ZFP compressed arrays only support short headers at this time.");
-
-    // verify metadata on zfp_field match that for this object
-    std::string err_msg = "";
-    if (type != zfp_field_type(zfh.field))
-      zfp::array::header::concat_sentence(err_msg, "ZFP header specified an underlying scalar type different than that for this object.");
-
-    if (dims != zfp_field_dimensionality(zfh.field))
-      zfp::array::header::concat_sentence(err_msg, "ZFP header specified a dimensionality different than that for this object.");
-
-    verify_header_contents(zfp, zfh.field, err_msg);
-
-    if (!err_msg.empty())
-      throw zfp::array::header::exception(err_msg);
-
-    // set class variables
-    nx = zfh.field->nx;
-    ny = zfh.field->ny;
-    nz = zfh.field->nz;
-    type = zfh.field->type;
-    blkbits = zfp->maxbits;
-  }
-
-  // default number of cache lines for array with n blocks
-  static uint lines(size_t n)
-  {
-    // compute m = O(sqrt(n))
-    size_t m;
-    for (m = 1; m * m < n; m *= 2);
-    return static_cast<uint>(m);
-  }
-
-  uint dims;           // array dimensionality (1, 2, or 3)
-  zfp_type type;       // scalar type
-  uint nx, ny, nz;     // array dimensions
-  uint bx, by, bz;     // array dimensions in number of blocks
-  uint blocks;         // number of blocks
-  size_t blkbits;      // number of bits per compressed block
-  size_t bytes;        // total bytes of compressed data
-  mutable uchar* data; // pointer to compressed data
-  zfp_stream* zfp;     // compressed stream of blocks
-  uchar* shape;        // precomputed block dimensions (or null if uniform)
-};
-
-#undef DIV_ROUND_UP
-#undef BITS_TO_BYTES
-
-#undef ZFP_HEADER_SIZE_BITS
-
-}
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/include/zfparray1.h b/ThirdParty/zfp/vtkzfp/include/zfparray1.h
deleted file mode 100644
index f95b430d139a0068c3eca0561a13cd32909d60c6..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfparray1.h
+++ /dev/null
@@ -1,297 +0,0 @@
-#ifndef ZFP_ARRAY1_H
-#define ZFP_ARRAY1_H
-
-#include <cstddef>
-#include <iterator>
-#include <cstring>
-#include "zfparray.h"
-#include "zfpcodec.h"
-#include "zfp/cache.h"
-
-namespace zfp {
-
-// compressed 1D array of scalars
-template < typename Scalar, class Codec = zfp::codec<Scalar> >
-class array1 : public array {
-public:
-  // forward declarations
-  class reference;
-  class pointer;
-  class iterator;
-  class view;
-  #include "zfp/reference1.h"
-  #include "zfp/pointer1.h"
-  #include "zfp/iterator1.h"
-  #include "zfp/view1.h"
-
-  // default constructor
-  array1() : array(1, Codec::type) {}
-
-  // constructor of n-sample array using rate bits per value, at least
-  // csize bytes of cache, and optionally initialized from flat array p
-  array1(uint n, double rate, const Scalar* p = 0, size_t csize = 0) :
-    array(1, Codec::type),
-    cache(lines(csize, n))
-  {
-    set_rate(rate);
-    resize(n, p == 0);
-    if (p)
-      set(p);
-  }
-
-  // constructor, from previously-serialized compressed array
-  array1(const zfp::array::header& h, const uchar* buffer = 0, size_t buffer_size_bytes = 0) :
-    array(1, Codec::type, h, buffer_size_bytes)
-  {
-    resize(nx, false);
-    if (buffer)
-      memcpy(data, buffer, bytes);
-  }
-
-  // copy constructor--performs a deep copy
-  array1(const array1& a) :
-    array()
-  {
-    deep_copy(a);
-  }
-
-  // construction from view--perform deep copy of (sub)array
-  template <class View>
-  array1(const View& v) :
-    array(1, Codec::type),
-    cache(lines(0, v.size_x()))
-  {
-    set_rate(v.rate());
-    resize(v.size_x(), true);
-    // initialize array in its preferred order
-    for (iterator it = begin(); it != end(); ++it)
-      *it = v(it.i());
-  }
-
-  // virtual destructor
-  virtual ~array1() {}
-
-  // assignment operator--performs a deep copy
-  array1& operator=(const array1& a)
-  {
-    if (this != &a)
-      deep_copy(a);
-    return *this;
-  }
-
-  // total number of elements in array
-  size_t size() const { return size_t(nx); }
-
-  // array dimensions
-  uint size_x() const { return nx; }
-
-  // resize the array (all previously stored data will be lost)
-  void resize(uint n, bool clear = true)
-  {
-    if (n == 0)
-      free();
-    else {
-      nx = n;
-      bx = (nx + 3) / 4;
-      blocks = bx;
-      alloc(clear);
-
-      // precompute block dimensions
-      zfp::deallocate(shape);
-      if (nx & 3u) {
-        shape = (uchar*)zfp::allocate(blocks);
-        uchar* p = shape;
-        for (uint i = 0; i < bx; i++)
-          *p++ = (i == bx - 1 ? -nx & 3u : 0);
-      }
-      else
-        shape = 0;
-    }
-  }
-
-  // cache size in number of bytes
-  size_t cache_size() const { return cache.size() * sizeof(CacheLine); }
-
-  // set minimum cache size in bytes (array dimensions must be known)
-  void set_cache_size(size_t csize)
-  {
-    flush_cache();
-    cache.resize(lines(csize, nx));
-  }
-
-  // empty cache without compressing modified cached blocks
-  void clear_cache() const { cache.clear(); }
-
-  // flush cache by compressing all modified cached blocks
-  void flush_cache() const
-  {
-    for (typename zfp::Cache<CacheLine>::const_iterator p = cache.first(); p; p++) {
-      if (p->tag.dirty()) {
-        uint b = p->tag.index() - 1;
-        encode(b, p->line->data());
-      }
-      cache.flush(p->line);
-    }
-  }
-
-  // decompress array and store at p
-  void get(Scalar* p) const
-  {
-    uint b = 0;
-    for (uint i = 0; i < bx; i++, p += 4, b++) {
-      const CacheLine* line = cache.lookup(b + 1);
-      if (line)
-        line->get(p, 1, shape ? shape[b] : 0);
-      else
-        decode(b, p, 1);
-    }
-  }
-
-  // initialize array by copying and compressing data stored at p
-  void set(const Scalar* p)
-  {
-    uint b = 0;
-    for (uint i = 0; i < bx; i++, b++, p += 4)
-      encode(b, p, 1);
-    cache.clear();
-  }
-
-  // (i) accessors
-  Scalar operator()(uint i) const { return get(i); }
-  reference operator()(uint i) { return reference(this, i); }
-
-  // flat index accessors
-  Scalar operator[](uint index) const { return get(index); }
-  reference operator[](uint index) { return reference(this, index); }
-
-  // random access iterators
-  iterator begin() { return iterator(this, 0); }
-  iterator end() { return iterator(this, nx); }
-
-protected:
-  // cache line representing one block of decompressed values
-  class CacheLine {
-  public:
-    Scalar operator()(uint i) const { return a[index(i)]; }
-    Scalar& operator()(uint i) { return a[index(i)]; }
-    const Scalar* data() const { return a; }
-    Scalar* data() { return a; }
-    // copy cache line
-    void get(Scalar* p, int sx) const
-    {
-      const Scalar* q = a;
-      for (uint x = 0; x < 4; x++, p += sx, q++)
-        *p = *q;
-    }
-    void get(Scalar* p, int sx, uint shape) const
-    {
-      if (!shape)
-        get(p, sx);
-      else {
-        // determine block dimensions
-        uint nx = 4 - (shape & 3u); shape >>= 2;
-        const Scalar* q = a;
-        for (uint x = 0; x < nx; x++, p += sx, q++)
-          *p = *q;
-      }
-    }
-  protected:
-    static uint index(uint i) { return i & 3u; }
-    Scalar a[4];
-  };
-
-  // perform a deep copy
-  void deep_copy(const array1& a)
-  {
-    // copy base class members
-    array::deep_copy(a);
-    // copy cache
-    cache = a.cache;
-  }
-
-  // inspector
-  Scalar get(uint i) const
-  {
-    const CacheLine* p = line(i, false);
-    return (*p)(i);
-  }
-
-  // mutator
-  void set(uint i, Scalar val)
-  {
-    CacheLine* p = line(i, true);
-    (*p)(i) = val;
-  }
-
-  // in-place updates
-  void add(uint i, Scalar val) { (*line(i, true))(i) += val; }
-  void sub(uint i, Scalar val) { (*line(i, true))(i) -= val; }
-  void mul(uint i, Scalar val) { (*line(i, true))(i) *= val; }
-  void div(uint i, Scalar val) { (*line(i, true))(i) /= val; }
-
-  // return cache line for i; may require write-back and fetch
-  CacheLine* line(uint i, bool write) const
-  {
-    CacheLine* p = 0;
-    uint b = block(i);
-    typename zfp::Cache<CacheLine>::Tag t = cache.access(p, b + 1, write);
-    uint c = t.index() - 1;
-    if (c != b) {
-      // write back occupied cache line if it is dirty
-      if (t.dirty())
-        encode(c, p->data());
-      // fetch cache line
-      decode(b, p->data());
-    }
-    return p;
-  }
-
-  // encode block with given index
-  void encode(uint index, const Scalar* block) const
-  {
-    stream_wseek(zfp->stream, index * blkbits);
-    Codec::encode_block_1(zfp, block, shape ? shape[index] : 0);
-    stream_flush(zfp->stream);
-  }
-
-  // encode block with given index from strided array
-  void encode(uint index, const Scalar* p, int sx) const
-  {
-    stream_wseek(zfp->stream, index * blkbits);
-    Codec::encode_block_strided_1(zfp, p, shape ? shape[index] : 0, sx);
-    stream_flush(zfp->stream);
-  }
-
-  // decode block with given index
-  void decode(uint index, Scalar* block) const
-  {
-    stream_rseek(zfp->stream, index * blkbits);
-    Codec::decode_block_1(zfp, block, shape ? shape[index] : 0);
-  }
-
-  // decode block with given index to strided array
-  void decode(uint index, Scalar* p, int sx) const
-  {
-    stream_rseek(zfp->stream, index * blkbits);
-    Codec::decode_block_strided_1(zfp, p, shape ? shape[index] : 0, sx);
-  }
-
-  // block index for i
-  static uint block(uint i) { return i / 4; }
-
-  // number of cache lines corresponding to size (or suggested size if zero)
-  static uint lines(size_t size, uint n)
-  {
-    n = size ? (size + sizeof(CacheLine) - 1) / sizeof(CacheLine) : array::lines(size_t((n + 3) / 4));
-    return std::max(n, 1u);
-  }
-
-  mutable zfp::Cache<CacheLine> cache; // cache of decompressed blocks
-};
-
-typedef array1<float> array1f;
-typedef array1<double> array1d;
-
-}
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/include/zfparray2.h b/ThirdParty/zfp/vtkzfp/include/zfparray2.h
deleted file mode 100644
index 73dfaa8d7fdb0aa4e3953123ae110ad5158e7117..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfparray2.h
+++ /dev/null
@@ -1,324 +0,0 @@
-#ifndef ZFP_ARRAY2_H
-#define ZFP_ARRAY2_H
-
-#include <cstddef>
-#include <iterator>
-#include <cstring>
-#include "zfparray.h"
-#include "zfpcodec.h"
-#include "zfp/cache.h"
-
-namespace zfp {
-
-// compressed 2D array of scalars
-template < typename Scalar, class Codec = zfp::codec<Scalar> >
-class array2 : public array {
-public:
-  // forward declarations
-  class reference;
-  class pointer;
-  class iterator;
-  class view;
-  #include "zfp/reference2.h"
-  #include "zfp/pointer2.h"
-  #include "zfp/iterator2.h"
-  #include "zfp/view2.h"
-
-  // default constructor
-  array2() : array(2, Codec::type) {}
-
-  // constructor of nx * ny array using rate bits per value, at least
-  // csize bytes of cache, and optionally initialized from flat array p
-  array2(uint nx, uint ny, double rate, const Scalar* p = 0, size_t csize = 0) :
-    array(2, Codec::type),
-    cache(lines(csize, nx, ny))
-  {
-    set_rate(rate);
-    resize(nx, ny, p == 0);
-    if (p)
-      set(p);
-  }
-
-  // constructor, from previously-serialized compressed array
-  array2(const zfp::array::header& h, const uchar* buffer = 0, size_t buffer_size_bytes = 0) :
-    array(2, Codec::type, h, buffer_size_bytes)
-  {
-    resize(nx, ny, false);
-    if (buffer)
-      memcpy(data, buffer, bytes);
-  }
-
-  // copy constructor--performs a deep copy
-  array2(const array2& a) :
-    array()
-  {
-    deep_copy(a);
-  }
-
-  // construction from view--perform deep copy of (sub)array
-  template <class View>
-  array2(const View& v) :
-    array(2, Codec::type),
-    cache(lines(0, v.size_x(), v.size_y()))
-  {
-    set_rate(v.rate());
-    resize(v.size_x(), v.size_y(), true);
-    // initialize array in its preferred order
-    for (iterator it = begin(); it != end(); ++it)
-      *it = v(it.i(), it.j());
-  }
-
-  // virtual destructor
-  virtual ~array2() {}
-
-  // assignment operator--performs a deep copy
-  array2& operator=(const array2& a)
-  {
-    if (this != &a)
-      deep_copy(a);
-    return *this;
-  }
-
-  // total number of elements in array
-  size_t size() const { return size_t(nx) * size_t(ny); }
-
-  // array dimensions
-  uint size_x() const { return nx; }
-  uint size_y() const { return ny; }
-
-  // resize the array (all previously stored data will be lost)
-  void resize(uint nx, uint ny, bool clear = true)
-  {
-    if (nx == 0 || ny == 0)
-      free();
-    else {
-      this->nx = nx;
-      this->ny = ny;
-      bx = (nx + 3) / 4;
-      by = (ny + 3) / 4;
-      blocks = bx * by;
-      alloc(clear);
-
-      // precompute block dimensions
-      zfp::deallocate(shape);
-      if ((nx | ny) & 3u) {
-        shape = (uchar*)zfp::allocate(blocks);
-        uchar* p = shape;
-        for (uint j = 0; j < by; j++)
-          for (uint i = 0; i < bx; i++)
-            *p++ = (i == bx - 1 ? -nx & 3u : 0) + 4 * (j == by - 1 ? -ny & 3u : 0);
-      }
-      else
-        shape = 0;
-    }
-  }
-
-  // cache size in number of bytes
-  size_t cache_size() const { return cache.size() * sizeof(CacheLine); }
-
-  // set minimum cache size in bytes (array dimensions must be known)
-  void set_cache_size(size_t csize)
-  {
-    flush_cache();
-    cache.resize(lines(csize, nx, ny));
-  }
-
-  // empty cache without compressing modified cached blocks
-  void clear_cache() const { cache.clear(); }
-
-  // flush cache by compressing all modified cached blocks
-  void flush_cache() const
-  {
-    for (typename zfp::Cache<CacheLine>::const_iterator p = cache.first(); p; p++) {
-      if (p->tag.dirty()) {
-        uint b = p->tag.index() - 1;
-        encode(b, p->line->data());
-      }
-      cache.flush(p->line);
-    }
-  }
-
-  // decompress array and store at p
-  void get(Scalar* p) const
-  {
-    uint b = 0;
-    for (uint j = 0; j < by; j++, p += 4 * (nx - bx))
-      for (uint i = 0; i < bx; i++, p += 4, b++) {
-        const CacheLine* line = cache.lookup(b + 1);
-        if (line)
-          line->get(p, 1, nx, shape ? shape[b] : 0);
-        else
-          decode(b, p, 1, nx);
-      }
-  }
-
-  // initialize array by copying and compressing data stored at p
-  void set(const Scalar* p)
-  {
-    uint b = 0;
-    for (uint j = 0; j < by; j++, p += 4 * (nx - bx))
-      for (uint i = 0; i < bx; i++, p += 4, b++)
-        encode(b, p, 1, nx);
-    cache.clear();
-  }
-
-  // (i, j) accessors
-  Scalar operator()(uint i, uint j) const { return get(i, j); }
-  reference operator()(uint i, uint j) { return reference(this, i, j); }
-
-  // flat index accessors
-  Scalar operator[](uint index) const
-  {
-    uint i, j;
-    ij(i, j, index);
-    return get(i, j);
-  }
-  reference operator[](uint index)
-  {
-    uint i, j;
-    ij(i, j, index);
-    return reference(this, i, j);
-  }
-
-  // sequential iterators
-  iterator begin() { return iterator(this, 0, 0); }
-  iterator end() { return iterator(this, 0, ny); }
-
-protected:
-  // cache line representing one block of decompressed values
-  class CacheLine {
-  public:
-    Scalar operator()(uint i, uint j) const { return a[index(i, j)]; }
-    Scalar& operator()(uint i, uint j) { return a[index(i, j)]; }
-    const Scalar* data() const { return a; }
-    Scalar* data() { return a; }
-    // copy cache line
-    void get(Scalar* p, int sx, int sy) const
-    {
-      const Scalar* q = a;
-      for (uint y = 0; y < 4; y++, p += sy - 4 * sx)
-        for (uint x = 0; x < 4; x++, p += sx, q++)
-          *p = *q;
-    }
-    void get(Scalar* p, int sx, int sy, uint shape) const
-    {
-      if (!shape)
-        get(p, sx, sy);
-      else {
-        // determine block dimensions
-        uint nx = 4 - (shape & 3u); shape >>= 2;
-        uint ny = 4 - (shape & 3u); shape >>= 2;
-        const Scalar* q = a;
-        for (uint y = 0; y < ny; y++, p += sy - (ptrdiff_t)nx * sx, q += 4 - nx)
-          for (uint x = 0; x < nx; x++, p += sx, q++)
-            *p = *q;
-      }
-    }
-  protected:
-    static uint index(uint i, uint j) { return (i & 3u) + 4 * (j & 3u); }
-    Scalar a[16];
-  };
-
-  // perform a deep copy
-  void deep_copy(const array2& a)
-  {
-    // copy base class members
-    array::deep_copy(a);
-    // copy cache
-    cache = a.cache;
-  }
-
-  // inspector
-  Scalar get(uint i, uint j) const
-  {
-    const CacheLine* p = line(i, j, false);
-    return (*p)(i, j);
-  }
-
-  // mutator
-  void set(uint i, uint j, Scalar val)
-  {
-    CacheLine* p = line(i, j, true);
-    (*p)(i, j) = val;
-  }
-
-  // in-place updates
-  void add(uint i, uint j, Scalar val) { (*line(i, j, true))(i, j) += val; }
-  void sub(uint i, uint j, Scalar val) { (*line(i, j, true))(i, j) -= val; }
-  void mul(uint i, uint j, Scalar val) { (*line(i, j, true))(i, j) *= val; }
-  void div(uint i, uint j, Scalar val) { (*line(i, j, true))(i, j) /= val; }
-
-  // return cache line for (i, j); may require write-back and fetch
-  CacheLine* line(uint i, uint j, bool write) const
-  {
-    CacheLine* p = 0;
-    uint b = block(i, j);
-    typename zfp::Cache<CacheLine>::Tag t = cache.access(p, b + 1, write);
-    uint c = t.index() - 1;
-    if (c != b) {
-      // write back occupied cache line if it is dirty
-      if (t.dirty())
-        encode(c, p->data());
-      // fetch cache line
-      decode(b, p->data());
-    }
-    return p;
-  }
-
-  // encode block with given index
-  void encode(uint index, const Scalar* block) const
-  {
-    stream_wseek(zfp->stream, index * blkbits);
-    Codec::encode_block_2(zfp, block, shape ? shape[index] : 0);
-    stream_flush(zfp->stream);
-  }
-
-  // encode block with given index from strided array
-  void encode(uint index, const Scalar* p, int sx, int sy) const
-  {
-    stream_wseek(zfp->stream, index * blkbits);
-    Codec::encode_block_strided_2(zfp, p, shape ? shape[index] : 0, sx, sy);
-    stream_flush(zfp->stream);
-  }
-
-  // decode block with given index
-  void decode(uint index, Scalar* block) const
-  {
-    stream_rseek(zfp->stream, index * blkbits);
-    Codec::decode_block_2(zfp, block, shape ? shape[index] : 0);
-  }
-
-  // decode block with given index to strided array
-  void decode(uint index, Scalar* p, int sx, int sy) const
-  {
-    stream_rseek(zfp->stream, index * blkbits);
-    Codec::decode_block_strided_2(zfp, p, shape ? shape[index] : 0, sx, sy);
-  }
-
-  // block index for (i, j)
-  uint block(uint i, uint j) const { return (i / 4) + bx * (j / 4); }
-
-  // convert flat index to (i, j)
-  void ij(uint& i, uint& j, uint index) const
-  {
-    i = index % nx;
-    index /= nx;
-    j = index;
-  }
-
-  // number of cache lines corresponding to size (or suggested size if zero)
-  static uint lines(size_t size, uint nx, uint ny)
-  {
-    uint n = size ? uint((size + sizeof(CacheLine) - 1) / sizeof(CacheLine)) : array::lines(size_t((nx + 3) / 4) * size_t((ny + 3) / 4));
-    return std::max(n, 1u);
-  }
-
-  mutable zfp::Cache<CacheLine> cache; // cache of decompressed blocks
-};
-
-typedef array2<float> array2f;
-typedef array2<double> array2d;
-
-}
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/include/zfparray3.h b/ThirdParty/zfp/vtkzfp/include/zfparray3.h
deleted file mode 100644
index f0f42e88e53a4b0dc51a46883c60552ac546f1ba..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfparray3.h
+++ /dev/null
@@ -1,338 +0,0 @@
-#ifndef ZFP_ARRAY3_H
-#define ZFP_ARRAY3_H
-
-#include <cstddef>
-#include <iterator>
-#include <cstring>
-#include "zfparray.h"
-#include "zfpcodec.h"
-#include "zfp/cache.h"
-
-namespace zfp {
-
-// compressed 3D array of scalars
-template < typename Scalar, class Codec = zfp::codec<Scalar> >
-class array3 : public array {
-public:
-  // forward declarations
-  class reference;
-  class pointer;
-  class iterator;
-  class view;
-  #include "zfp/reference3.h"
-  #include "zfp/pointer3.h"
-  #include "zfp/iterator3.h"
-  #include "zfp/view3.h"
-
-  // default constructor
-  array3() : array(3, Codec::type) {}
-
-  // constructor of nx * ny * nz array using rate bits per value, at least
-  // csize bytes of cache, and optionally initialized from flat array p
-  array3(uint nx, uint ny, uint nz, double rate, const Scalar* p = 0, size_t csize = 0) :
-    array(3, Codec::type),
-    cache(lines(csize, nx, ny, nz))
-  {
-    set_rate(rate);
-    resize(nx, ny, nz, p == 0);
-    if (p)
-      set(p);
-  }
-
-  // constructor, from previously-serialized compressed array
-  array3(const zfp::array::header& h, const uchar* buffer = 0, size_t buffer_size_bytes = 0) :
-    array(3, Codec::type, h, buffer_size_bytes)
-  {
-    resize(nx, ny, nz, false);
-    if (buffer)
-      memcpy(data, buffer, bytes);
-  }
-
-  // copy constructor--performs a deep copy
-  array3(const array3& a) :
-    array()
-  {
-    deep_copy(a);
-  }
-
-  // construction from view--perform deep copy of (sub)array
-  template <class View>
-  array3(const View& v) :
-    array(3, Codec::type),
-    cache(lines(0, v.size_x(), v.size_y(), v.size_z()))
-  {
-    set_rate(v.rate());
-    resize(v.size_x(), v.size_y(), v.size_z(), true);
-    // initialize array in its preferred order
-    for (iterator it = begin(); it != end(); ++it)
-      *it = v(it.i(), it.j(), it.k());
-  }
-
-  // virtual destructor
-  virtual ~array3() {}
-
-  // assignment operator--performs a deep copy
-  array3& operator=(const array3& a)
-  {
-    if (this != &a)
-      deep_copy(a);
-    return *this;
-  }
-
-  // total number of elements in array
-  size_t size() const { return size_t(nx) * size_t(ny) * size_t(nz); }
-
-  // array dimensions
-  uint size_x() const { return nx; }
-  uint size_y() const { return ny; }
-  uint size_z() const { return nz; }
-
-  // resize the array (all previously stored data will be lost)
-  void resize(uint nx, uint ny, uint nz, bool clear = true)
-  {
-    if (nx == 0 || ny == 0 || nz == 0)
-      free();
-    else {
-      this->nx = nx;
-      this->ny = ny;
-      this->nz = nz;
-      bx = (nx + 3) / 4;
-      by = (ny + 3) / 4;
-      bz = (nz + 3) / 4;
-      blocks = bx * by * bz;
-      alloc(clear);
-
-      // precompute block dimensions
-      zfp::deallocate(shape);
-      if ((nx | ny | nz) & 3u) {
-        shape = (uchar*)zfp::allocate(blocks);
-        uchar* p = shape;
-        for (uint k = 0; k < bz; k++)
-          for (uint j = 0; j < by; j++)
-            for (uint i = 0; i < bx; i++)
-              *p++ = (i == bx - 1 ? -nx & 3u : 0) + 4 * ((j == by - 1 ? -ny & 3u : 0) + 4 * (k == bz - 1 ? -nz & 3u : 0));
-      }
-      else
-        shape = 0;
-    }
-  }
-
-  // cache size in number of bytes
-  size_t cache_size() const { return cache.size() * sizeof(CacheLine); }
-
-  // set minimum cache size in bytes (array dimensions must be known)
-  void set_cache_size(size_t csize)
-  {
-    flush_cache();
-    cache.resize(lines(csize, nx, ny, nz));
-  }
-
-  // empty cache without compressing modified cached blocks
-  void clear_cache() const { cache.clear(); }
-
-  // flush cache by compressing all modified cached blocks
-  void flush_cache() const
-  {
-    for (typename zfp::Cache<CacheLine>::const_iterator p = cache.first(); p; p++) {
-      if (p->tag.dirty()) {
-        uint b = p->tag.index() - 1;
-        encode(b, p->line->data());
-      }
-      cache.flush(p->line);
-    }
-  }
-
-  // decompress array and store at p
-  void get(Scalar* p) const
-  {
-    uint b = 0;
-    for (uint k = 0; k < bz; k++, p += 4 * nx * (ny - by))
-      for (uint j = 0; j < by; j++, p += 4 * (nx - bx))
-        for (uint i = 0; i < bx; i++, p += 4, b++) {
-          const CacheLine* line = cache.lookup(b + 1);
-          if (line)
-            line->get(p, 1, nx, nx * ny, shape ? shape[b] : 0);
-          else
-            decode(b, p, 1, nx, nx * ny);
-        }
-  }
-
-  // initialize array by copying and compressing data stored at p
-  void set(const Scalar* p)
-  {
-    uint b = 0;
-    for (uint k = 0; k < bz; k++, p += 4 * nx * (ny - by))
-      for (uint j = 0; j < by; j++, p += 4 * (nx - bx))
-        for (uint i = 0; i < bx; i++, p += 4, b++)
-          encode(b, p, 1, nx, nx * ny);
-    cache.clear();
-  }
-
-  // (i, j, k) accessors
-  Scalar operator()(uint i, uint j, uint k) const { return get(i, j, k); }
-  reference operator()(uint i, uint j, uint k) { return reference(this, i, j, k); }
-
-  // flat index corresponding to (i, j, k)
-  uint index(uint i, uint j, uint k) const { return i + nx * (j + ny * k); }
-
-  // flat index accessors
-  Scalar operator[](uint index) const
-  {
-    uint i, j, k;
-    ijk(i, j, k, index);
-    return get(i, j, k);
-  }
-  reference operator[](uint index)
-  {
-    uint i, j, k;
-    ijk(i, j, k, index);
-    return reference(this, i, j, k);
-  }
-
-  // sequential iterators
-  iterator begin() { return iterator(this, 0, 0, 0); }
-  iterator end() { return iterator(this, 0, 0, nz); }
-
-protected:
-  // cache line representing one block of decompressed values
-  class CacheLine {
-  public:
-    Scalar operator()(uint i, uint j, uint k) const { return a[index(i, j, k)]; }
-    Scalar& operator()(uint i, uint j, uint k) { return a[index(i, j, k)]; }
-    const Scalar* data() const { return a; }
-    Scalar* data() { return a; }
-    // copy cache line
-    void get(Scalar* p, int sx, int sy, int sz) const
-    {
-      const Scalar* q = a;
-      for (uint z = 0; z < 4; z++, p += sz - 4 * sy)
-        for (uint y = 0; y < 4; y++, p += sy - 4 * sx)
-          for (uint x = 0; x < 4; x++, p += sx, q++)
-            *p = *q;
-    }
-    void get(Scalar* p, int sx, int sy, int sz, uint shape) const
-    {
-      if (!shape)
-        get(p, sx, sy, sz);
-      else {
-        // determine block dimensions
-        uint nx = 4 - (shape & 3u); shape >>= 2;
-        uint ny = 4 - (shape & 3u); shape >>= 2;
-        uint nz = 4 - (shape & 3u); shape >>= 2;
-        const Scalar* q = a;
-        for (uint z = 0; z < nz; z++, p += sz - (ptrdiff_t)ny * sy, q += 16 - 4 * ny)
-          for (uint y = 0; y < ny; y++, p += sy - (ptrdiff_t)nx * sx, q += 4 - nx)
-            for (uint x = 0; x < nx; x++, p += sx, q++)
-              *p = *q;
-      }
-    }
-  protected:
-    static uint index(uint i, uint j, uint k) { return (i & 3u) + 4 * ((j & 3u) + 4 * (k & 3u)); }
-    Scalar a[64];
-  };
-
-  // perform a deep copy
-  void deep_copy(const array3& a)
-  {
-    // copy base class members
-    array::deep_copy(a);
-    // copy cache
-    cache = a.cache;
-  }
-
-  // inspector
-  Scalar get(uint i, uint j, uint k) const
-  {
-    const CacheLine* p = line(i, j, k, false);
-    return (*p)(i, j, k);
-  }
-
-  // mutator
-  void set(uint i, uint j, uint k, Scalar val)
-  {
-    CacheLine* p = line(i, j, k, true);
-    (*p)(i, j, k) = val;
-  }
-
-  // in-place updates
-  void add(uint i, uint j, uint k, Scalar val) { (*line(i, j, k, true))(i, j, k) += val; }
-  void sub(uint i, uint j, uint k, Scalar val) { (*line(i, j, k, true))(i, j, k) -= val; }
-  void mul(uint i, uint j, uint k, Scalar val) { (*line(i, j, k, true))(i, j, k) *= val; }
-  void div(uint i, uint j, uint k, Scalar val) { (*line(i, j, k, true))(i, j, k) /= val; }
-
-  // return cache line for (i, j, k); may require write-back and fetch
-  CacheLine* line(uint i, uint j, uint k, bool write) const
-  {
-    CacheLine* p = 0;
-    uint b = block(i, j, k);
-    typename zfp::Cache<CacheLine>::Tag t = cache.access(p, b + 1, write);
-    uint c = t.index() - 1;
-    if (c != b) {
-      // write back occupied cache line if it is dirty
-      if (t.dirty())
-        encode(c, p->data());
-      // fetch cache line
-      decode(b, p->data());
-    }
-    return p;
-  }
-
-  // encode block with given index
-  void encode(uint index, const Scalar* block) const
-  {
-    stream_wseek(zfp->stream, index * blkbits);
-    Codec::encode_block_3(zfp, block, shape ? shape[index] : 0);
-    stream_flush(zfp->stream);
-  }
-
-  // encode block with given index from strided array
-  void encode(uint index, const Scalar* p, int sx, int sy, int sz) const
-  {
-    stream_wseek(zfp->stream, index * blkbits);
-    Codec::encode_block_strided_3(zfp, p, shape ? shape[index] : 0, sx, sy, sz);
-    stream_flush(zfp->stream);
-  }
-
-  // decode block with given index
-  void decode(uint index, Scalar* block) const
-  {
-    stream_rseek(zfp->stream, index * blkbits);
-    Codec::decode_block_3(zfp, block, shape ? shape[index] : 0);
-  }
-
-  // decode block with given index to strided array
-  void decode(uint index, Scalar* p, int sx, int sy, int sz) const
-  {
-    stream_rseek(zfp->stream, index * blkbits);
-    Codec::decode_block_strided_3(zfp, p, shape ? shape[index] : 0, sx, sy, sz);
-  }
-
-  // block index for (i, j, k)
-  uint block(uint i, uint j, uint k) const { return (i / 4) + bx * ((j / 4) + by * (k / 4)); }
-
-  // convert flat index to (i, j, k)
-  void ijk(uint& i, uint& j, uint& k, uint index) const
-  {
-    i = index % nx;
-    index /= nx;
-    j = index % ny;
-    index /= ny;
-    k = index;
-  }
-
-  // number of cache lines corresponding to size (or suggested size if zero)
-  static uint lines(size_t size, uint nx, uint ny, uint nz)
-  {
-    uint n = size ? (size + sizeof(CacheLine) - 1) / sizeof(CacheLine) : array::lines(size_t((nx + 3) / 4) * size_t((ny + 3) / 4) * size_t((nz + 3) / 4));
-    return std::max(n, 1u);
-  }
-
-  mutable zfp::Cache<CacheLine> cache; // cache of decompressed blocks
-};
-
-typedef array3<float> array3f;
-typedef array3<double> array3d;
-
-}
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/include/zfpcodec.h b/ThirdParty/zfp/vtkzfp/include/zfpcodec.h
deleted file mode 100644
index 2d4674444e07f3262943df3c7e543ce14e3d66e0..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfpcodec.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef ZFP_CODEC_H
-#define ZFP_CODEC_H
-
-#include "zfp.h"
-
-namespace zfp {
-
-// C++ wrappers around libzfp C functions
-template <typename Scalar>
-struct codec {};
-
-#include "zfpcodecf.h"
-#include "zfpcodecd.h"
-
-}
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/include/zfpcodecd.h b/ThirdParty/zfp/vtkzfp/include/zfpcodecd.h
deleted file mode 100644
index 9e7d893234062afb0801573c01f2100c73848183..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfpcodecd.h
+++ /dev/null
@@ -1,149 +0,0 @@
-// double-precision codec
-template <>
-struct codec<double> {
-  // encode contiguous 1D block
-  static void encode_block_1(zfp_stream* zfp, const double* block, uint shape)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      zfp_encode_partial_block_strided_double_1(zfp, block, nx, 1);
-    }
-    else
-      zfp_encode_block_double_1(zfp, block);
-  }
-
-  // encode 1D block from strided storage
-  static void encode_block_strided_1(zfp_stream* zfp, const double* p, uint shape, int sx)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      zfp_encode_partial_block_strided_double_1(zfp, p, nx, sx);
-    }
-    else
-      zfp_encode_block_strided_double_1(zfp, p, sx);
-  }
-
-  // encode contiguous 2D block
-  static void encode_block_2(zfp_stream* zfp, const double* block, uint shape)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      zfp_encode_partial_block_strided_double_2(zfp, block, nx, ny, 1, 4);
-    }
-    else
-      zfp_encode_block_double_2(zfp, block);
-  }
-
-  // encode 2D block from strided storage
-  static void encode_block_strided_2(zfp_stream* zfp, const double* p, uint shape, int sx, int sy)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      zfp_encode_partial_block_strided_double_2(zfp, p, nx, ny, sx, sy);
-    }
-    else
-      zfp_encode_block_strided_double_2(zfp, p, sx, sy);
-  }
-
-  // encode contiguous 3D block
-  static void encode_block_3(zfp_stream* zfp, const double* block, uint shape)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      uint nz = 4 - (shape & 3u); shape >>= 2;
-      zfp_encode_partial_block_strided_double_3(zfp, block, nx, ny, nz, 1, 4, 16);
-    }
-    else
-      zfp_encode_block_double_3(zfp, block);
-  }
-
-  // encode 3D block from strided storage
-  static void encode_block_strided_3(zfp_stream* zfp, const double* p, uint shape, int sx, int sy, int sz)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      uint nz = 4 - (shape & 3u); shape >>= 2;
-      zfp_encode_partial_block_strided_double_3(zfp, p, nx, ny, nz, sx, sy, sz);
-    }
-    else
-      zfp_encode_block_strided_double_3(zfp, p, sx, sy, sz);
-  }
-
-  // decode contiguous 1D block
-  static void decode_block_1(zfp_stream* zfp, double* block, uint shape)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      zfp_decode_partial_block_strided_double_1(zfp, block, nx, 1);
-    }
-    else
-      zfp_decode_block_double_1(zfp, block);
-  }
-
-  // decode 1D block to strided storage
-  static void decode_block_strided_1(zfp_stream* zfp, double* p, uint shape, int sx)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      zfp_decode_partial_block_strided_double_1(zfp, p, nx, sx);
-    }
-    else
-      zfp_decode_block_strided_double_1(zfp, p, sx);
-  }
-
-  // decode contiguous 2D block
-  static void decode_block_2(zfp_stream* zfp, double* block, uint shape)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      zfp_decode_partial_block_strided_double_2(zfp, block, nx, ny, 1, 4);
-    }
-    else
-      zfp_decode_block_double_2(zfp, block);
-  }
-
-  // decode 2D block to strided storage
-  static void decode_block_strided_2(zfp_stream* zfp, double* p, uint shape, int sx, int sy)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      zfp_decode_partial_block_strided_double_2(zfp, p, nx, ny, sx, sy);
-    }
-    else
-      zfp_decode_block_strided_double_2(zfp, p, sx, sy);
-  }
-
-  // decode contiguous 3D block
-  static void decode_block_3(zfp_stream* zfp, double* block, uint shape)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      uint nz = 4 - (shape & 3u); shape >>= 2;
-      zfp_decode_partial_block_strided_double_3(zfp, block, nx, ny, nz, 1, 4, 16);
-    }
-    else
-      zfp_decode_block_double_3(zfp, block);
-  }
-
-  // decode 3D block to strided storage
-  static void decode_block_strided_3(zfp_stream* zfp, double* p, uint shape, int sx, int sy, int sz)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      uint nz = 4 - (shape & 3u); shape >>= 2;
-      zfp_decode_partial_block_strided_double_3(zfp, p, nx, ny, nz, sx, sy, sz);
-    }
-    else
-      zfp_decode_block_strided_double_3(zfp, p, sx, sy, sz);
-  }
-
-  static const zfp_type type = zfp_type_double;
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfpcodecf.h b/ThirdParty/zfp/vtkzfp/include/zfpcodecf.h
deleted file mode 100644
index 1ec74a60990281d545886ad5f49a699d18c14a10..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfpcodecf.h
+++ /dev/null
@@ -1,149 +0,0 @@
-// single-precision codec
-template <>
-struct codec<float> {
-  // encode contiguous 1D block
-  static void encode_block_1(zfp_stream* zfp, const float* block, uint shape)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      zfp_encode_partial_block_strided_float_1(zfp, block, nx, 1);
-    }
-    else
-      zfp_encode_block_float_1(zfp, block);
-  }
-
-  // encode 1D block from strided storage
-  static void encode_block_strided_1(zfp_stream* zfp, const float* p, uint shape, int sx)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      zfp_encode_partial_block_strided_float_1(zfp, p, nx, sx);
-    }
-    else
-      zfp_encode_block_strided_float_1(zfp, p, sx);
-  }
-
-  // encode contiguous 2D block
-  static void encode_block_2(zfp_stream* zfp, const float* block, uint shape)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      zfp_encode_partial_block_strided_float_2(zfp, block, nx, ny, 1, 4);
-    }
-    else
-      zfp_encode_block_float_2(zfp, block);
-  }
-
-  // encode 2D block from strided storage
-  static void encode_block_strided_2(zfp_stream* zfp, const float* p, uint shape, int sx, int sy)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      zfp_encode_partial_block_strided_float_2(zfp, p, nx, ny, sx, sy);
-    }
-    else
-      zfp_encode_block_strided_float_2(zfp, p, sx, sy);
-  }
-
-  // encode contiguous 3D block
-  static void encode_block_3(zfp_stream* zfp, const float* block, uint shape)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      uint nz = 4 - (shape & 3u); shape >>= 2;
-      zfp_encode_partial_block_strided_float_3(zfp, block, nx, ny, nz, 1, 4, 16);
-    }
-    else
-      zfp_encode_block_float_3(zfp, block);
-  }
-
-  // encode 3D block from strided storage
-  static void encode_block_strided_3(zfp_stream* zfp, const float* p, uint shape, int sx, int sy, int sz)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      uint nz = 4 - (shape & 3u); shape >>= 2;
-      zfp_encode_partial_block_strided_float_3(zfp, p, nx, ny, nz, sx, sy, sz);
-    }
-    else
-      zfp_encode_block_strided_float_3(zfp, p, sx, sy, sz);
-  }
-
-  // decode contiguous 1D block
-  static void decode_block_1(zfp_stream* zfp, float* block, uint shape)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      zfp_decode_partial_block_strided_float_1(zfp, block, nx, 1);
-    }
-    else
-      zfp_decode_block_float_1(zfp, block);
-  }
-
-  // decode 1D block to strided storage
-  static void decode_block_strided_1(zfp_stream* zfp, float* p, uint shape, int sx)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      zfp_decode_partial_block_strided_float_1(zfp, p, nx, sx);
-    }
-    else
-      zfp_decode_block_strided_float_1(zfp, p, sx);
-  }
-
-  // decode contiguous 2D block
-  static void decode_block_2(zfp_stream* zfp, float* block, uint shape)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      zfp_decode_partial_block_strided_float_2(zfp, block, nx, ny, 1, 4);
-    }
-    else
-      zfp_decode_block_float_2(zfp, block);
-  }
-
-  // decode 2D block to strided storage
-  static void decode_block_strided_2(zfp_stream* zfp, float* p, uint shape, int sx, int sy)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      zfp_decode_partial_block_strided_float_2(zfp, p, nx, ny, sx, sy);
-    }
-    else
-      zfp_decode_block_strided_float_2(zfp, p, sx, sy);
-  }
-
-  // decode contiguous 3D block
-  static void decode_block_3(zfp_stream* zfp, float* block, uint shape)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      uint nz = 4 - (shape & 3u); shape >>= 2;
-      zfp_decode_partial_block_strided_float_3(zfp, block, nx, ny, nz, 1, 4, 16);
-    }
-    else
-      zfp_decode_block_float_3(zfp, block);
-  }
-
-  // decode 3D block to strided storage
-  static void decode_block_strided_3(zfp_stream* zfp, float* p, uint shape, int sx, int sy, int sz)
-  {
-    if (shape) {
-      uint nx = 4 - (shape & 3u); shape >>= 2;
-      uint ny = 4 - (shape & 3u); shape >>= 2;
-      uint nz = 4 - (shape & 3u); shape >>= 2;
-      zfp_decode_partial_block_strided_float_3(zfp, p, nx, ny, nz, sx, sy, sz);
-    }
-    else
-      zfp_decode_block_strided_float_3(zfp, p, sx, sy, sz);
-  }
-
-  static const zfp_type type = zfp_type_float;
-};
diff --git a/ThirdParty/zfp/vtkzfp/include/zfpfactory.h b/ThirdParty/zfp/vtkzfp/include/zfpfactory.h
deleted file mode 100644
index 44910bd258ab2468400ff0be3c270e18cb96bfa1..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/include/zfpfactory.h
+++ /dev/null
@@ -1,98 +0,0 @@
-#ifndef ZFP_FACTORY_H
-#define ZFP_FACTORY_H
-
-// (assumes zfparray.h already included)
-
-zfp::array* zfp::array::construct(const zfp::array::header& header, const uchar* buffer, size_t buffer_size_bytes)
-{
-  // gather array metadata via C API, then construct with metadata
-  uint dims = 0;
-  zfp_type type = zfp_type_none;
-  double rate = 0;
-  uint n[4] = {0};
-
-  // read once (will throw if reads a noncompatible header)
-  zfp::array::read_header_contents(header, buffer_size_bytes, dims, type, rate, n);
-
-  // construct once (passing zfp::array::header will read it again)
-  zfp::array* arr = 0;
-  std::string err_msg = "";
-  switch (dims) {
-    case 3:
-#ifdef ZFP_ARRAY3_H
-      switch (type) {
-        case zfp_type_double:
-          arr = new zfp::array3d(n[0], n[1], n[2], rate);
-          break;
-
-        case zfp_type_float:
-          arr = new zfp::array3f(n[0], n[1], n[2], rate);
-          break;
-
-        default:
-          /* NOTREACHED */
-          err_msg = "Unexpected ZFP type.";
-          break;
-      }
-#else
-      err_msg = "Header files for 3 dimensional ZFP compressed arrays were not included.";
-#endif
-      break;
-
-    case 2:
-#ifdef ZFP_ARRAY2_H
-      switch (type) {
-        case zfp_type_double:
-          arr = new zfp::array2d(n[0], n[1], rate);
-          break;
-
-        case zfp_type_float:
-          arr = new zfp::array2f(n[0], n[1], rate);
-          break;
-
-        default:
-          /* NOTREACHED */
-          err_msg = "Unexpected ZFP type.";
-          break;
-      }
-#else
-      err_msg = "Header files for 2 dimensional ZFP compressed arrays were not included.";
-#endif
-      break;
-
-    case 1:
-#ifdef ZFP_ARRAY1_H
-      switch (type) {
-        case zfp_type_double:
-          arr = new zfp::array1d(n[0], rate);
-          break;
-
-        case zfp_type_float:
-          arr = new zfp::array1f(n[0], rate);
-          break;
-
-        default:
-          /* NOTREACHED */
-          err_msg = "Unexpected ZFP type.";
-          break;
-      }
-#else
-      err_msg = "Header files for 1 dimensional ZFP compressed arrays were not included.";
-#endif
-      break;
-
-    default:
-      err_msg = "ZFP compressed arrays do not yet support dimensionalities beyond 1, 2, and 3.";
-      break;
-  }
-
-  if (!err_msg.empty())
-    throw zfp::array::header::exception(err_msg);
-
-  if (buffer)
-    memcpy(arr->compressed_data(), buffer, arr->compressed_size());
-
-  return arr;
-}
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/src/bitstream.c b/ThirdParty/zfp/vtkzfp/src/bitstream.c
deleted file mode 100644
index 05094c6d31befd5947e7b49164cc7eeb315fa95c..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/bitstream.c
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "bitstream.h"
-#include "inline/bitstream.c"
-
-export_ const size_t stream_word_bits = wsize;
diff --git a/ThirdParty/zfp/vtkzfp/src/block1.h b/ThirdParty/zfp/vtkzfp/src/block1.h
deleted file mode 100644
index 035d9c9523d63ff46b76dd648bf99b5503781016..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/block1.h
+++ /dev/null
@@ -1 +0,0 @@
-#define DIMS 1
diff --git a/ThirdParty/zfp/vtkzfp/src/block2.h b/ThirdParty/zfp/vtkzfp/src/block2.h
deleted file mode 100644
index e87ab62995ad655de67ed64a1e466e7622a3a758..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/block2.h
+++ /dev/null
@@ -1 +0,0 @@
-#define DIMS 2
diff --git a/ThirdParty/zfp/vtkzfp/src/block3.h b/ThirdParty/zfp/vtkzfp/src/block3.h
deleted file mode 100644
index a683568673a3f619d23ece9a3abd92b965a6aea6..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/block3.h
+++ /dev/null
@@ -1 +0,0 @@
-#define DIMS 3
diff --git a/ThirdParty/zfp/vtkzfp/src/block4.h b/ThirdParty/zfp/vtkzfp/src/block4.h
deleted file mode 100644
index 6737fb25eaf4ed27653c2fc737d6d73ee058ffe7..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/block4.h
+++ /dev/null
@@ -1 +0,0 @@
-#define DIMS 4
diff --git a/ThirdParty/zfp/vtkzfp/src/decode1d.c b/ThirdParty/zfp/vtkzfp/src/decode1d.c
deleted file mode 100644
index 436515a92ee42ad920a5f6f57891b8d38562428f..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode1d.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block1.h"
-#include "traitsd.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec1.c"
-#include "template/decode.c"
-#include "template/decodef.c"
-#include "template/decode1.c"
-#include "template/revcodecf.c"
-#include "template/revdecode.c"
-#include "template/revdecodef.c"
-#include "template/revdecode1.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode1f.c b/ThirdParty/zfp/vtkzfp/src/decode1f.c
deleted file mode 100644
index 443b8522fb2f216e4595803819532d76a36c76f9..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode1f.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block1.h"
-#include "traitsf.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec1.c"
-#include "template/decode.c"
-#include "template/decodef.c"
-#include "template/decode1.c"
-#include "template/revcodecf.c"
-#include "template/revdecode.c"
-#include "template/revdecodef.c"
-#include "template/revdecode1.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode1i.c b/ThirdParty/zfp/vtkzfp/src/decode1i.c
deleted file mode 100644
index 73f58e6c06c565f5f8c8545d2b372a8aa322c0bc..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode1i.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block1.h"
-#include "traitsi.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec1.c"
-#include "template/decode.c"
-#include "template/decodei.c"
-#include "template/decode1.c"
-#include "template/revdecode.c"
-#include "template/revdecode1.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode1l.c b/ThirdParty/zfp/vtkzfp/src/decode1l.c
deleted file mode 100644
index cedcc532efa6881694a1aa27a9333c6aa5a5cddb..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode1l.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block1.h"
-#include "traitsl.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec1.c"
-#include "template/decode.c"
-#include "template/decodei.c"
-#include "template/decode1.c"
-#include "template/revdecode.c"
-#include "template/revdecode1.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode2d.c b/ThirdParty/zfp/vtkzfp/src/decode2d.c
deleted file mode 100644
index 8c3a994d6b3750b18c3edf8ae0735a461aa4f612..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode2d.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block2.h"
-#include "traitsd.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec2.c"
-#include "template/decode.c"
-#include "template/decodef.c"
-#include "template/decode2.c"
-#include "template/revcodecf.c"
-#include "template/revdecode.c"
-#include "template/revdecodef.c"
-#include "template/revdecode2.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode2f.c b/ThirdParty/zfp/vtkzfp/src/decode2f.c
deleted file mode 100644
index 7b3c35cf20e6ae8c1ece3a99782c74de28a06c7c..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode2f.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block2.h"
-#include "traitsf.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec2.c"
-#include "template/decode.c"
-#include "template/decodef.c"
-#include "template/decode2.c"
-#include "template/revcodecf.c"
-#include "template/revdecode.c"
-#include "template/revdecodef.c"
-#include "template/revdecode2.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode2i.c b/ThirdParty/zfp/vtkzfp/src/decode2i.c
deleted file mode 100644
index 70a4a5a21ff5e35e4572f87396a6cd44354d0a0a..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode2i.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block2.h"
-#include "traitsi.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec2.c"
-#include "template/decode.c"
-#include "template/decodei.c"
-#include "template/decode2.c"
-#include "template/revdecode.c"
-#include "template/revdecode2.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode2l.c b/ThirdParty/zfp/vtkzfp/src/decode2l.c
deleted file mode 100644
index 93a2cf833539b4cd7932e9cf9eb2ba4d8adebb53..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode2l.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block2.h"
-#include "traitsl.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec2.c"
-#include "template/decode.c"
-#include "template/decodei.c"
-#include "template/decode2.c"
-#include "template/revdecode.c"
-#include "template/revdecode2.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode3d.c b/ThirdParty/zfp/vtkzfp/src/decode3d.c
deleted file mode 100644
index b8cb9d18a494d27c50ba4fe2175b29df046a5741..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode3d.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block3.h"
-#include "traitsd.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec3.c"
-#include "template/decode.c"
-#include "template/decodef.c"
-#include "template/decode3.c"
-#include "template/revcodecf.c"
-#include "template/revdecode.c"
-#include "template/revdecodef.c"
-#include "template/revdecode3.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode3f.c b/ThirdParty/zfp/vtkzfp/src/decode3f.c
deleted file mode 100644
index 914c49991663096ae4b7b3315ebb60158aee7953..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode3f.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block3.h"
-#include "traitsf.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec3.c"
-#include "template/decode.c"
-#include "template/decodef.c"
-#include "template/decode3.c"
-#include "template/revcodecf.c"
-#include "template/revdecode.c"
-#include "template/revdecodef.c"
-#include "template/revdecode3.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode3i.c b/ThirdParty/zfp/vtkzfp/src/decode3i.c
deleted file mode 100644
index 46af93e0636035a37be1a60e1a510c2c7cfa2e8d..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode3i.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block3.h"
-#include "traitsi.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec3.c"
-#include "template/decode.c"
-#include "template/decodei.c"
-#include "template/decode3.c"
-#include "template/revdecode.c"
-#include "template/revdecode3.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode3l.c b/ThirdParty/zfp/vtkzfp/src/decode3l.c
deleted file mode 100644
index 1e76d171a8f10af26c08426864bcc244c03e6d81..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode3l.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block3.h"
-#include "traitsl.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec3.c"
-#include "template/decode.c"
-#include "template/decodei.c"
-#include "template/decode3.c"
-#include "template/revdecode.c"
-#include "template/revdecode3.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode4d.c b/ThirdParty/zfp/vtkzfp/src/decode4d.c
deleted file mode 100644
index ee5b31fcc657111a192d0f1b4f73b160c474761b..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode4d.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block4.h"
-#include "traitsd.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec4.c"
-#include "template/decode.c"
-#include "template/decodef.c"
-#include "template/decode4.c"
-#include "template/revcodecf.c"
-#include "template/revdecode.c"
-#include "template/revdecodef.c"
-#include "template/revdecode4.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode4f.c b/ThirdParty/zfp/vtkzfp/src/decode4f.c
deleted file mode 100644
index 5eb3b900fd28e435d477081314c5cc56d10cfcd7..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode4f.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block4.h"
-#include "traitsf.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec4.c"
-#include "template/decode.c"
-#include "template/decodef.c"
-#include "template/decode4.c"
-#include "template/revcodecf.c"
-#include "template/revdecode.c"
-#include "template/revdecodef.c"
-#include "template/revdecode4.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode4i.c b/ThirdParty/zfp/vtkzfp/src/decode4i.c
deleted file mode 100644
index b871eba407eb5346cd6517d8ba2ef0143fc3d0cb..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode4i.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block4.h"
-#include "traitsi.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec4.c"
-#include "template/decode.c"
-#include "template/decodei.c"
-#include "template/decode4.c"
-#include "template/revdecode.c"
-#include "template/revdecode4.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/decode4l.c b/ThirdParty/zfp/vtkzfp/src/decode4l.c
deleted file mode 100644
index b37e47e116530ea577a298a1958c41bdff9e7035..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/decode4l.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block4.h"
-#include "traitsl.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec4.c"
-#include "template/decode.c"
-#include "template/decodei.c"
-#include "template/decode4.c"
-#include "template/revdecode.c"
-#include "template/revdecode4.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode1d.c b/ThirdParty/zfp/vtkzfp/src/encode1d.c
deleted file mode 100644
index 84b9ac8c041b7fc98d8301e730af402da7d7baf9..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode1d.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block1.h"
-#include "traitsd.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec1.c"
-#include "template/encode.c"
-#include "template/encodef.c"
-#include "template/encode1.c"
-#include "template/revcodecf.c"
-#include "template/revencode.c"
-#include "template/revencodef.c"
-#include "template/revencode1.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode1f.c b/ThirdParty/zfp/vtkzfp/src/encode1f.c
deleted file mode 100644
index a57a7cf703a5e53d720d5801f43bc688e742a7f8..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode1f.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block1.h"
-#include "traitsf.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec1.c"
-#include "template/encode.c"
-#include "template/encodef.c"
-#include "template/encode1.c"
-#include "template/revcodecf.c"
-#include "template/revencode.c"
-#include "template/revencodef.c"
-#include "template/revencode1.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode1i.c b/ThirdParty/zfp/vtkzfp/src/encode1i.c
deleted file mode 100644
index dcd9aa64b293406b4ef06e70e286f7889778dde0..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode1i.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block1.h"
-#include "traitsi.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec1.c"
-#include "template/encode.c"
-#include "template/encodei.c"
-#include "template/encode1.c"
-#include "template/revencode.c"
-#include "template/revencode1.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode1l.c b/ThirdParty/zfp/vtkzfp/src/encode1l.c
deleted file mode 100644
index 032c3de61ca6770b8330624abe421004200908ed..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode1l.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block1.h"
-#include "traitsl.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec1.c"
-#include "template/encode.c"
-#include "template/encodei.c"
-#include "template/encode1.c"
-#include "template/revencode.c"
-#include "template/revencode1.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode2d.c b/ThirdParty/zfp/vtkzfp/src/encode2d.c
deleted file mode 100644
index 50e8dd8354093f93f6ceb14f1ccb29421330cf7f..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode2d.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block2.h"
-#include "traitsd.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec2.c"
-#include "template/encode.c"
-#include "template/encodef.c"
-#include "template/encode2.c"
-#include "template/revcodecf.c"
-#include "template/revencode.c"
-#include "template/revencodef.c"
-#include "template/revencode2.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode2f.c b/ThirdParty/zfp/vtkzfp/src/encode2f.c
deleted file mode 100644
index 713a74e4d9d0e9a02e4c9df32d456e128e3aabc5..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode2f.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block2.h"
-#include "traitsf.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec2.c"
-#include "template/encode.c"
-#include "template/encodef.c"
-#include "template/encode2.c"
-#include "template/revcodecf.c"
-#include "template/revencode.c"
-#include "template/revencodef.c"
-#include "template/revencode2.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode2i.c b/ThirdParty/zfp/vtkzfp/src/encode2i.c
deleted file mode 100644
index d0b4b54c6b30028a0189dcb3548e87e51c34acf8..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode2i.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block2.h"
-#include "traitsi.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec2.c"
-#include "template/encode.c"
-#include "template/encodei.c"
-#include "template/encode2.c"
-#include "template/revencode.c"
-#include "template/revencode2.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode2l.c b/ThirdParty/zfp/vtkzfp/src/encode2l.c
deleted file mode 100644
index d834cfa1d62f40fad784eefde6ba188c0085d872..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode2l.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block2.h"
-#include "traitsl.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec2.c"
-#include "template/encode.c"
-#include "template/encodei.c"
-#include "template/encode2.c"
-#include "template/revencode.c"
-#include "template/revencode2.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode3d.c b/ThirdParty/zfp/vtkzfp/src/encode3d.c
deleted file mode 100644
index 16c385e283f630755559cf79ff49a30ff5a8606e..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode3d.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block3.h"
-#include "traitsd.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec3.c"
-#include "template/encode.c"
-#include "template/encodef.c"
-#include "template/encode3.c"
-#include "template/revcodecf.c"
-#include "template/revencode.c"
-#include "template/revencodef.c"
-#include "template/revencode3.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode3f.c b/ThirdParty/zfp/vtkzfp/src/encode3f.c
deleted file mode 100644
index 1668aff87bfd9dbb8c7c9b41be021ca99448f716..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode3f.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block3.h"
-#include "traitsf.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec3.c"
-#include "template/encode.c"
-#include "template/encodef.c"
-#include "template/encode3.c"
-#include "template/revcodecf.c"
-#include "template/revencode.c"
-#include "template/revencodef.c"
-#include "template/revencode3.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode3i.c b/ThirdParty/zfp/vtkzfp/src/encode3i.c
deleted file mode 100644
index c92a1a6986ee88b68c5313a1151c433be03a2465..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode3i.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block3.h"
-#include "traitsi.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec3.c"
-#include "template/encode.c"
-#include "template/encodei.c"
-#include "template/encode3.c"
-#include "template/revencode.c"
-#include "template/revencode3.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode3l.c b/ThirdParty/zfp/vtkzfp/src/encode3l.c
deleted file mode 100644
index 4d53304eda4c7c9c8d4d7f54f0bb1460315cc6b9..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode3l.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block3.h"
-#include "traitsl.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec3.c"
-#include "template/encode.c"
-#include "template/encodei.c"
-#include "template/encode3.c"
-#include "template/revencode.c"
-#include "template/revencode3.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode4d.c b/ThirdParty/zfp/vtkzfp/src/encode4d.c
deleted file mode 100644
index c82d19a1b317ec720c255515f8fb5693f9a1479c..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode4d.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block4.h"
-#include "traitsd.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec4.c"
-#include "template/encode.c"
-#include "template/encodef.c"
-#include "template/encode4.c"
-#include "template/revcodecf.c"
-#include "template/revencode.c"
-#include "template/revencodef.c"
-#include "template/revencode4.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode4f.c b/ThirdParty/zfp/vtkzfp/src/encode4f.c
deleted file mode 100644
index e0ce014691b7b49d21d1b69a7d21a823130af2e8..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode4f.c
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block4.h"
-#include "traitsf.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codecf.c"
-#include "template/codec4.c"
-#include "template/encode.c"
-#include "template/encodef.c"
-#include "template/encode4.c"
-#include "template/revcodecf.c"
-#include "template/revencode.c"
-#include "template/revencodef.c"
-#include "template/revencode4.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode4i.c b/ThirdParty/zfp/vtkzfp/src/encode4i.c
deleted file mode 100644
index ab82e0e2e5502e0ab598e9158fe720570a2c62a0..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode4i.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block4.h"
-#include "traitsi.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec4.c"
-#include "template/encode.c"
-#include "template/encodei.c"
-#include "template/encode4.c"
-#include "template/revencode.c"
-#include "template/revencode4.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/encode4l.c b/ThirdParty/zfp/vtkzfp/src/encode4l.c
deleted file mode 100644
index 805ee01a665108fde47458f5df20df715a99d9b9..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/encode4l.c
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "inline/inline.h"
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "block4.h"
-#include "traitsl.h"
-#include "template/template.h"
-#include "template/codec.h"
-#include "inline/bitstream.c"
-#include "template/codec4.c"
-#include "template/encode.c"
-#include "template/encodei.c"
-#include "template/encode4.c"
-#include "template/revencode.c"
-#include "template/revencode4.c"
diff --git a/ThirdParty/zfp/vtkzfp/src/inline/bitstream.c b/ThirdParty/zfp/vtkzfp/src/inline/bitstream.c
deleted file mode 100644
index aa58b73fdb890b5f926db7e5c1346d37ba3bf431..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/inline/bitstream.c
+++ /dev/null
@@ -1,457 +0,0 @@
-/*
-High-speed in-memory bit stream I/O that supports reading and writing between
-0 and 64 bits at a time.  The implementation, which relies heavily on bit
-shifts, has been carefully written to ensure that all shifts are between
-zero and one less the width of the type being shifted to avoid undefined
-behavior.  This occasionally causes somewhat convoluted code.
-
-The following assumptions and restrictions apply:
-
-1. The user must allocate a memory buffer large enough to hold the bit stream,
-   whether for reading, writing, or both.  This buffer is associated with the
-   bit stream via stream_open(buffer, bytes), which allocates and returns a
-   pointer to an opaque bit stream struct.  Call stream_close(stream) to
-   deallocate this struct.
-
-2. The stream is either in a read or write state (or, initially, in both
-   states).  When done writing, call stream_flush(stream) before entering
-   read mode to ensure any buffered bits are output.  To enter read mode,
-   call stream_rewind(stream) or stream_rseek(stream, offset) to position
-   the stream at the beginning or at a particular bit offset.  Conversely,
-   stream_rewind(stream) or stream_wseek(stream, offset) positions the
-   stream for writing.  In read mode, the following functions may be called:
-
-     size_t stream_size(stream);
-     size_t stream_rtell(stream);
-     void stream_rewind(stream);
-     void stream_rseek(stream, offset);
-     void stream_skip(stream, uint n);
-     size_t stream_align(stream);
-     uint stream_read_bit(stream);
-     uint64 stream_read_bits(stream, n);
-
-   Each of the above read calls has a corresponding write call:
-
-     size_t stream_size(stream);
-     size_t stream_wtell(stream);
-     void stream_rewind(stream);
-     void stream_wseek(stream, offset);
-     void stream_pad(stream, n);
-     size_t stream_flush(stream);
-     uint stream_write_bit(stream, bit);
-     uint64 stream_write_bits(stream, value, n);
-
-3. The stream buffer is an unsigned integer of a user-specified type given
-   by the BIT_STREAM_WORD_TYPE macro.  Bits are read and written in units of
-   this integer word type.  Supported types are 8, 16, 32, or 64 bits wide.
-   The bit width of the buffer is denoted by 'wsize' and can be accessed via
-   the global constant stream_word_bits.  A small wsize allows for fine
-   granularity reads and writes, and may be preferable when working with many
-   small blocks of data that require non-sequential access.  The default
-   maximum size of 64 bits ensures maximum speed.  Note that even when
-   wsize < 64, it is still possible to read and write up to 64 bits at a time
-   using stream_read_bits() and stream_write_bits().
-
-4. If BIT_STREAM_STRIDED is defined, words read from or written to the stream
-   may be accessed noncontiguously by setting a power-of-two block size (which
-   by default is one word) and a block stride (defaults to zero blocks).  The
-   word pointer is always incremented by one word each time a word is accessed.
-   Once advanced past a block boundary, the word pointer is also advanced by
-   the stride to the next block.  This feature may be used to store blocks of
-   data interleaved, e.g. for progressive coding or for noncontiguous parallel
-   access to the bit stream  Note that the block size is measured in words,
-   while the stride is measured in multiples of the block size.  Strided access
-   can have a significant performance penalty.
-
-5. Multiple bits are read and written in order of least to most significant
-   bit.  Thus, the statement
-
-       value = stream_write_bits(stream, value, n);
-
-   is essentially equivalent to (but faster than)
-
-       for (i = 0; i < n; i++, value >>= 1)
-         stream_write_bit(value & 1);
-
-   when 0 <= n <= 64.  The same holds for read calls, and thus
-
-       value = stream_read_bits(stream, n);
-
-   is essentially equivalent to
-
-       for (i = 0, value = 0; i < n; i++)
-         value += (uint64)stream_read_bit() << i;
-
-   Note that it is possible to write fewer bits than the argument 'value'
-   holds (possibly even no bits), in which case any unwritten bits are
-   returned.
-
-6. Although the stream_wseek(stream, offset) call allows positioning the
-   stream for writing at any bit offset without any data loss (i.e. all
-   previously written bits preceding the offset remain valid), for efficiency
-   the stream_flush(stream) operation will zero all bits up to the next
-   multiple of wsize bits, thus overwriting bits that were previously stored
-   at that location.  Consequently, random write access is effectively
-   supported only at wsize granularity.  For sequential access, the largest
-   possible wsize is preferred due to higher speed.
-
-7. It is up to the user to adhere to these rules.  For performance reasons,
-   no error checking is done, and in particular buffer overruns are not
-   caught.
-*/
-
-#include <limits.h>
-#include <stdlib.h>
-
-#ifndef inline_
-  #define inline_
-#endif
-
-/* satisfy compiler when args unused */
-#define unused_(x) ((void)(x))
-
-/* bit stream word/buffer type; granularity of stream I/O operations */
-#ifdef BIT_STREAM_WORD_TYPE
-  /* may be 8-, 16-, 32-, or 64-bit unsigned integer type */
-  typedef BIT_STREAM_WORD_TYPE word;
-#else
-  /* use maximum word size by default for highest speed */
-  typedef uint64 word;
-#endif
-
-/* number of bits in a buffered word */
-#define wsize ((uint)(CHAR_BIT * sizeof(word)))
-
-/* bit stream structure (opaque to caller) */
-struct bitstream {
-  uint bits;   /* number of buffered bits (0 <= bits < wsize) */
-  word buffer; /* buffer for incoming/outgoing bits (buffer < 2^bits) */
-  word* ptr;   /* pointer to next word to be read/written */
-  word* begin; /* beginning of stream */
-  word* end;   /* end of stream (currently unused) */
-#ifdef BIT_STREAM_STRIDED
-  size_t mask;     /* one less the block size in number of words */
-  ptrdiff_t delta; /* number of words between consecutive blocks */
-#endif
-};
-
-/* private functions ------------------------------------------------------- */
-
-/* read a single word from memory */
-static word
-stream_read_word(bitstream* s)
-{
-  word w = *s->ptr++;
-#ifdef BIT_STREAM_STRIDED
-  if (!((s->ptr - s->begin) & s->mask))
-    s->ptr += s->delta;
-#endif
-  return w;
-}
-
-/* write a single word to memory */
-static void
-stream_write_word(bitstream* s, word value)
-{
-  *s->ptr++ = value;
-#ifdef BIT_STREAM_STRIDED
-  if (!((s->ptr - s->begin) & s->mask))
-    s->ptr += s->delta;
-#endif
-}
-
-/* public functions -------------------------------------------------------- */
-
-/* pointer to beginning of stream */
-inline_ void*
-stream_data(const bitstream* s)
-{
-  return s->begin;
-}
-
-/* current byte size of stream (if flushed) */
-inline_ size_t
-stream_size(const bitstream* s)
-{
-  return sizeof(word) * (s->ptr - s->begin);
-}
-
-/* byte capacity of stream */
-inline_ size_t
-stream_capacity(const bitstream* s)
-{
-  return sizeof(word) * (s->end - s->begin);
-}
-
-/* number of words per block */
-inline_ size_t
-stream_stride_block(const bitstream* s)
-{
-#ifdef BIT_STREAM_STRIDED
-  return s->mask + 1;
-#else
-  unused_(s);
-  return 1;
-#endif
-}
-
-/* number of blocks between consecutive stream blocks */
-inline_ ptrdiff_t
-stream_stride_delta(const bitstream* s)
-{
-#ifdef BIT_STREAM_STRIDED
-  return s->delta / (s->mask + 1);
-#else
-  unused_(s);
-  return 0;
-#endif
-}
-
-/* read single bit (0 or 1) */
-inline_ uint
-stream_read_bit(bitstream* s)
-{
-  uint bit;
-  if (!s->bits) {
-    s->buffer = stream_read_word(s);
-    s->bits = wsize;
-  }
-  s->bits--;
-  bit = (uint)s->buffer & 1u;
-  s->buffer >>= 1;
-  return bit;
-}
-
-/* write single bit (must be 0 or 1) */
-inline_ uint
-stream_write_bit(bitstream* s, uint bit)
-{
-  s->buffer += (word)bit << s->bits;
-  if (++s->bits == wsize) {
-    stream_write_word(s, s->buffer);
-    s->buffer = 0;
-    s->bits = 0;
-  }
-  return bit;
-}
-
-/* read 0 <= n <= 64 bits */
-inline_ uint64
-stream_read_bits(bitstream* s, uint n)
-{
-  uint64 value = s->buffer;
-  if (s->bits < n) {
-    /* keep fetching wsize bits until enough bits are buffered */
-    do {
-      /* assert: 0 <= s->bits < n <= 64 */
-      s->buffer = stream_read_word(s);
-      value += (uint64)s->buffer << s->bits;
-      s->bits += wsize;
-    } while (sizeof(s->buffer) < sizeof(value) && s->bits < n);
-    /* assert: 1 <= n <= s->bits < n + wsize */
-    s->bits -= n;
-    if (!s->bits) {
-      /* value holds exactly n bits; no need for masking */
-      s->buffer = 0;
-    }
-    else {
-      /* assert: 1 <= s->bits < wsize */
-      s->buffer >>= wsize - s->bits;
-      /* assert: 1 <= n <= 64 */
-      value &= ((uint64)2 << (n - 1)) - 1;
-    }
-  }
-  else {
-    /* assert: 0 <= n <= s->bits < wsize <= 64 */
-    s->bits -= n;
-    s->buffer >>= n;
-    value &= ((uint64)1 << n) - 1;
-  }
-  return value;
-}
-
-/* write 0 <= n <= 64 low bits of value and return remaining bits */
-inline_ uint64
-stream_write_bits(bitstream* s, uint64 value, uint n)
-{
-  /* append bit string to buffer */
-  s->buffer += (word)(value << s->bits);
-  s->bits += n;
-  /* is buffer full? */
-  if (s->bits >= wsize) {
-    /* 1 <= n <= 64; decrement n to ensure valid right shifts below */
-    value >>= 1;
-    n--;
-    /* assert: 0 <= n < 64; wsize <= s->bits <= wsize + n */
-    do {
-      /* output wsize bits while buffer is full */
-      s->bits -= wsize;
-      /* assert: 0 <= s->bits <= n */
-      stream_write_word(s, s->buffer);
-      /* assert: 0 <= n - s->bits < 64 */
-      s->buffer = (word)(value >> (n - s->bits));
-    } while (sizeof(s->buffer) < sizeof(value) && s->bits >= wsize);
-  }
-  /* assert: 0 <= s->bits < wsize */
-  s->buffer &= ((word)1 << s->bits) - 1;
-  /* assert: 0 <= n < 64 */
-  return value >> n;
-}
-
-/* return bit offset to next bit to be read */
-inline_ size_t
-stream_rtell(const bitstream* s)
-{
-  return wsize * (s->ptr - s->begin) - s->bits;
-}
-
-/* return bit offset to next bit to be written */
-inline_ size_t
-stream_wtell(const bitstream* s)
-{
-  return wsize * (s->ptr - s->begin) + s->bits;
-}
-
-/* position stream for reading or writing at beginning */
-inline_ void
-stream_rewind(bitstream* s)
-{
-  s->ptr = s->begin;
-  s->buffer = 0;
-  s->bits = 0;
-}
-
-/* position stream for reading at given bit offset */
-inline_ void
-stream_rseek(bitstream* s, size_t offset)
-{
-  uint n = offset % wsize;
-  s->ptr = s->begin + offset / wsize;
-  if (n) {
-    s->buffer = stream_read_word(s) >> n;
-    s->bits = wsize - n;
-  }
-  else {
-    s->buffer = 0;
-    s->bits = 0;
-  }
-}
-
-/* position stream for writing at given bit offset */
-inline_ void
-stream_wseek(bitstream* s, size_t offset)
-{
-  uint n = offset % wsize;
-  s->ptr = s->begin + offset / wsize;
-  if (n) {
-    word buffer = *s->ptr;
-    buffer &= ((word)1 << n) - 1;
-    s->buffer = buffer;
-    s->bits = n;
-  }
-  else {
-    s->buffer = 0;
-    s->bits = 0;
-  }
-}
-
-/* skip over the next n bits (n >= 0) */
-inline_ void
-stream_skip(bitstream* s, uint n)
-{
-  stream_rseek(s, stream_rtell(s) + n);
-}
-
-/* append n zero-bits to stream (n >= 0) */
-inline_ void
-stream_pad(bitstream* s, uint n)
-{
-  for (s->bits += n; s->bits >= wsize; s->bits -= wsize) {
-    stream_write_word(s, s->buffer);
-    s->buffer = 0;
-  }
-}
-
-/* align stream on next word boundary */
-inline_ size_t
-stream_align(bitstream* s)
-{
-  uint bits = s->bits;
-  if (bits)
-    stream_skip(s, bits);
-  return bits;
-}
-
-/* write any remaining buffered bits and align stream on next word boundary */
-inline_ size_t
-stream_flush(bitstream* s)
-{
-  uint bits = (wsize - s->bits) % wsize;
-  if (bits)
-    stream_pad(s, bits);
-  return bits;
-}
-
-/* copy n bits from one bit stream to another */
-inline_ void
-stream_copy(bitstream* dst, bitstream* src, size_t n)
-{
-  while (n > wsize) {
-    word w = (word)stream_read_bits(src, wsize);
-    stream_write_bits(dst, w, wsize);
-    n -= wsize;
-  }
-  if (n) {
-    word w = (word)stream_read_bits(src, (uint)n);
-    stream_write_bits(dst, w, (uint)n);
-  }
-}
-
-#ifdef BIT_STREAM_STRIDED
-/* set block size in number of words and spacing in number of blocks */
-inline_ int
-stream_set_stride(bitstream* s, size_t block, ptrdiff_t delta)
-{
-  /* ensure block size is a power of two */
-  if (block & (block - 1))
-    return 0;
-  s->mask = block - 1;
-  s->delta = delta * block;
-  return 1;
-}
-#endif
-
-/* allocate and initialize bit stream to user-allocated buffer */
-inline_ bitstream*
-stream_open(void* buffer, size_t bytes)
-{
-  bitstream* s = (bitstream*)malloc(sizeof(bitstream));
-  if (s) {
-    s->begin = (word*)buffer;
-    s->end = s->begin + bytes / sizeof(word);
-#ifdef BIT_STREAM_STRIDED
-    stream_set_stride(s, 0, 0);
-#endif
-    stream_rewind(s);
-  }
-  return s;
-}
-
-/* close and deallocate bit stream */
-inline_ void
-stream_close(bitstream* s)
-{
-  free(s);
-}
-
-/* make a copy of bit stream to shared memory buffer */
-inline_ bitstream*
-stream_clone(const bitstream* s)
-{
-  bitstream* c = (bitstream*)malloc(sizeof(bitstream));
-  if (c)
-    *c = *s;
-  return c;
-}
-
-#undef unused_
diff --git a/ThirdParty/zfp/vtkzfp/src/inline/inline.h b/ThirdParty/zfp/vtkzfp/src/inline/inline.h
deleted file mode 100644
index e9ade3f11d8f85b64711880cbee8198e737a6448..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/inline/inline.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef INLINE_H
-#define INLINE_H
-
-#ifndef inline_
-  #if __STDC_VERSION__ >= 199901L
-    #define inline_ static inline
-  #else
-    #define inline_ static
-  #endif
-#endif
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/src/share/omp.c b/ThirdParty/zfp/vtkzfp/src/share/omp.c
deleted file mode 100644
index 9ee26b9a68aae56f3fb6e75054fb4b4ddb60d786..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/share/omp.c
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifdef _OPENMP
-#include <omp.h>
-
-/* number of omp threads to use */
-static int
-thread_count_omp(const zfp_stream* stream)
-{
-  int count = stream->exec.params.omp.threads;
-  /* if no thread count is specified, use default number of threads */
-  if (!count)
-    count = omp_get_max_threads();
-  return count;
-}
-
-/* number of chunks to partition array into */
-static uint
-chunk_count_omp(const zfp_stream* stream, uint blocks, uint threads)
-{
-  uint chunk_size = stream->exec.params.omp.chunk_size;
-  /* if no chunk size is specified, assign one chunk per thread */
-  uint chunks = chunk_size ? (blocks + chunk_size - 1) / chunk_size : threads;
-  return MIN(chunks, blocks);
-}
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/src/share/parallel.c b/ThirdParty/zfp/vtkzfp/src/share/parallel.c
deleted file mode 100644
index e778ac7c23687b71bd1c6e437fb82b5c22dc37f2..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/share/parallel.c
+++ /dev/null
@@ -1,100 +0,0 @@
-#ifdef _OPENMP
-
-/* block index at which chunk begins */
-static uint
-chunk_offset(uint blocks, uint chunks, uint chunk)
-{
-  return (uint)((blocks * (uint64)chunk) / chunks);
-}
-
-/* initialize per-thread bit streams for parallel compression */
-static bitstream**
-compress_init_par(zfp_stream* stream, const zfp_field* field, uint chunks, uint blocks)
-{
-  bitstream** bs;
-  size_t size;
-  int copy = 0;
-  uint i;
-
-  /* determine maximum size buffer needed per thread */
-  zfp_field f = *field;
-  switch (zfp_field_dimensionality(field)) {
-    case 1:
-      f.nx = 4 * (blocks + chunks - 1) / chunks;
-      break;
-    case 2:
-      f.nx = 4;
-      f.ny = 4 * (blocks + chunks - 1) / chunks;
-      break;
-    case 3:
-      f.nx = 4;
-      f.ny = 4;
-      f.nz = 4 * (blocks + chunks - 1) / chunks;
-      break;
-    case 4:
-      f.nx = 4;
-      f.ny = 4;
-      f.nz = 4;
-      f.nw = 4 * (blocks + chunks - 1) / chunks;
-      break;
-    default:
-      return NULL;
-  }
-  size = zfp_stream_maximum_size(stream, &f);
-
-  /* avoid copies in fixed-rate mode when each bitstream is word aligned */
-  copy |= stream->minbits != stream->maxbits;
-  copy |= (stream->maxbits % stream_word_bits) != 0;
-  copy |= (stream_wtell(stream->stream) % stream_word_bits) != 0;
-
-  /* set up buffer for each thread to compress to */
-  bs = (bitstream**)malloc(chunks * sizeof(bitstream*));
-  if (!bs)
-    return NULL;
-  for (i = 0; i < chunks; i++) {
-    uint block = chunk_offset(blocks, chunks, i);
-    void* buffer = copy ? malloc(size) : (uchar*)stream_data(stream->stream) + stream_size(stream->stream) + block * stream->maxbits / CHAR_BIT;
-    if (!buffer)
-      break;
-    bs[i] = stream_open(buffer, size);
-  }
-
-  /* handle memory allocation failure */
-  if (copy && i < chunks) {
-    while (i--) {
-      free(stream_data(bs[i]));
-      stream_close(bs[i]);
-    }
-    free(bs);
-    bs = NULL;
-  }
-
-  return bs;
-}
-
-/* flush and concatenate bit streams if needed */
-static void
-compress_finish_par(zfp_stream* stream, bitstream** src, uint chunks)
-{
-  bitstream* dst = zfp_stream_bit_stream(stream);
-  int copy = (stream_data(dst) != stream_data(*src));
-  size_t offset = stream_wtell(dst);
-  uint i;
-  for (i = 0; i < chunks; i++) {
-    size_t bits = stream_wtell(src[i]);
-    offset += bits;
-    stream_flush(src[i]);
-    /* concatenate streams if they are not already contiguous */
-    if (copy) {
-      stream_rewind(src[i]);
-      stream_copy(dst, src[i], bits);
-      free(stream_data(src[i]));
-    }
-    stream_close(src[i]);
-  }
-  free(src);
-  if (!copy)
-    stream_wseek(dst, offset);
-}
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/src/template/codec.h b/ThirdParty/zfp/vtkzfp/src/template/codec.h
deleted file mode 100644
index e4b4acf9543795c49f23894c8fd141149a8b6751..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/codec.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#define PERM _t1(perm, DIMS)           /* coefficient order */
-#define BLOCK_SIZE (1 << (2 * DIMS))   /* values per block */
-#define EBIAS ((1 << (EBITS - 1)) - 1) /* exponent bias */
-#define REVERSIBLE(zfp) ((zfp)->minexp < ZFP_MIN_EXP) /* reversible mode? */
diff --git a/ThirdParty/zfp/vtkzfp/src/template/codec1.c b/ThirdParty/zfp/vtkzfp/src/template/codec1.c
deleted file mode 100644
index 5a4786471a940610d67472fd90858177b7d452d6..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/codec1.c
+++ /dev/null
@@ -1,4 +0,0 @@
-/* order coefficients by polynomial degree/frequency */
-cache_align_(static const uchar perm_1[4]) = {
-  0, 1, 2, 3
-};
diff --git a/ThirdParty/zfp/vtkzfp/src/template/codec2.c b/ThirdParty/zfp/vtkzfp/src/template/codec2.c
deleted file mode 100644
index a0f977024d6e73203ecbd14e6b605c949d799023..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/codec2.c
+++ /dev/null
@@ -1,32 +0,0 @@
-#define index(i, j) ((i) + 4 * (j))
-
-/* order coefficients (i, j) by i + j, then i^2 + j^2 */
-cache_align_(static const uchar perm_2[16]) = {
-  index(0, 0), /*  0 : 0 */
-
-  index(1, 0), /*  1 : 1 */
-  index(0, 1), /*  2 : 1 */
-
-  index(1, 1), /*  3 : 2 */
-
-  index(2, 0), /*  4 : 2 */
-  index(0, 2), /*  5 : 2 */
-
-  index(2, 1), /*  6 : 3 */
-  index(1, 2), /*  7 : 3 */
-
-  index(3, 0), /*  8 : 3 */
-  index(0, 3), /*  9 : 3 */
-
-  index(2, 2), /* 10 : 4 */
-
-  index(3, 1), /* 11 : 4 */
-  index(1, 3), /* 12 : 4 */
-
-  index(3, 2), /* 13 : 5 */
-  index(2, 3), /* 14 : 5 */
-
-  index(3, 3), /* 15 : 6 */
-};
-
-#undef index
diff --git a/ThirdParty/zfp/vtkzfp/src/template/codec3.c b/ThirdParty/zfp/vtkzfp/src/template/codec3.c
deleted file mode 100644
index b95f302720317b13bea8b53814646dccc42b6de2..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/codec3.c
+++ /dev/null
@@ -1,90 +0,0 @@
-#define index(i, j, k) ((i) + 4 * ((j) + 4 * (k)))
-
-/* order coefficients (i, j, k) by i + j + k, then i^2 + j^2 + k^2 */
-cache_align_(static const uchar perm_3[64]) = {
-  index(0, 0, 0), /*  0 : 0 */
-
-  index(1, 0, 0), /*  1 : 1 */
-  index(0, 1, 0), /*  2 : 1 */
-  index(0, 0, 1), /*  3 : 1 */
-
-  index(0, 1, 1), /*  4 : 2 */
-  index(1, 0, 1), /*  5 : 2 */
-  index(1, 1, 0), /*  6 : 2 */
-
-  index(2, 0, 0), /*  7 : 2 */
-  index(0, 2, 0), /*  8 : 2 */
-  index(0, 0, 2), /*  9 : 2 */
-
-  index(1, 1, 1), /* 10 : 3 */
-
-  index(2, 1, 0), /* 11 : 3 */
-  index(2, 0, 1), /* 12 : 3 */
-  index(0, 2, 1), /* 13 : 3 */
-  index(1, 2, 0), /* 14 : 3 */
-  index(1, 0, 2), /* 15 : 3 */
-  index(0, 1, 2), /* 16 : 3 */
-
-  index(3, 0, 0), /* 17 : 3 */
-  index(0, 3, 0), /* 18 : 3 */
-  index(0, 0, 3), /* 19 : 3 */
-
-  index(2, 1, 1), /* 20 : 4 */
-  index(1, 2, 1), /* 21 : 4 */
-  index(1, 1, 2), /* 22 : 4 */
-
-  index(0, 2, 2), /* 23 : 4 */
-  index(2, 0, 2), /* 24 : 4 */
-  index(2, 2, 0), /* 25 : 4 */
-
-  index(3, 1, 0), /* 26 : 4 */
-  index(3, 0, 1), /* 27 : 4 */
-  index(0, 3, 1), /* 28 : 4 */
-  index(1, 3, 0), /* 29 : 4 */
-  index(1, 0, 3), /* 30 : 4 */
-  index(0, 1, 3), /* 31 : 4 */
-
-  index(1, 2, 2), /* 32 : 5 */
-  index(2, 1, 2), /* 33 : 5 */
-  index(2, 2, 1), /* 34 : 5 */
-
-  index(3, 1, 1), /* 35 : 5 */
-  index(1, 3, 1), /* 36 : 5 */
-  index(1, 1, 3), /* 37 : 5 */
-
-  index(3, 2, 0), /* 38 : 5 */
-  index(3, 0, 2), /* 39 : 5 */
-  index(0, 3, 2), /* 40 : 5 */
-  index(2, 3, 0), /* 41 : 5 */
-  index(2, 0, 3), /* 42 : 5 */
-  index(0, 2, 3), /* 43 : 5 */
-
-  index(2, 2, 2), /* 44 : 6 */
-
-  index(3, 2, 1), /* 45 : 6 */
-  index(3, 1, 2), /* 46 : 6 */
-  index(1, 3, 2), /* 47 : 6 */
-  index(2, 3, 1), /* 48 : 6 */
-  index(2, 1, 3), /* 49 : 6 */
-  index(1, 2, 3), /* 50 : 6 */
-
-  index(0, 3, 3), /* 51 : 6 */
-  index(3, 0, 3), /* 52 : 6 */
-  index(3, 3, 0), /* 53 : 6 */
-
-  index(3, 2, 2), /* 54 : 7 */
-  index(2, 3, 2), /* 55 : 7 */
-  index(2, 2, 3), /* 56 : 7 */
-
-  index(1, 3, 3), /* 57 : 7 */
-  index(3, 1, 3), /* 58 : 7 */
-  index(3, 3, 1), /* 59 : 7 */
-
-  index(2, 3, 3), /* 60 : 8 */
-  index(3, 2, 3), /* 61 : 8 */
-  index(3, 3, 2), /* 62 : 8 */
-
-  index(3, 3, 3), /* 63 : 9 */
-};
-
-#undef index
diff --git a/ThirdParty/zfp/vtkzfp/src/template/codec4.c b/ThirdParty/zfp/vtkzfp/src/template/codec4.c
deleted file mode 100644
index b8314525cd42802a3ad8463191cea96bddef9661..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/codec4.c
+++ /dev/null
@@ -1,297 +0,0 @@
-#define index(i, j, k, l) ((i) + 4 * ((j) + 4 * ((k) + 4 * (l))))
-
-/* order coefficients (i, j, k, l) by i + j + k + l, then i^2 + j^2 + k^2 + l^2 */
-cache_align_(static const uchar perm_4[256]) = {
-  index(0, 0, 0, 0), /*   0 :  0 */
-
-  index(1, 0, 0, 0), /*   1 :  1 */
-  index(0, 1, 0, 0), /*   2 :  1 */
-  index(0, 0, 1, 0), /*   3 :  1 */
-  index(0, 0, 0, 1), /*   4 :  1 */
-
-  index(1, 1, 0, 0), /*   5 :  2 */
-  index(0, 0, 1, 1), /*   6 :  2 */
-  index(1, 0, 1, 0), /*   7 :  2 */
-  index(0, 1, 0, 1), /*   8 :  2 */
-  index(1, 0, 0, 1), /*   9 :  2 */
-  index(0, 1, 1, 0), /*  10 :  2 */
-
-  index(2, 0, 0, 0), /*  11 :  2 */
-  index(0, 2, 0, 0), /*  12 :  2 */
-  index(0, 0, 2, 0), /*  13 :  2 */
-  index(0, 0, 0, 2), /*  14 :  2 */
-
-  index(0, 1, 1, 1), /*  15 :  3 */
-  index(1, 0, 1, 1), /*  16 :  3 */
-  index(1, 1, 0, 1), /*  17 :  3 */
-  index(1, 1, 1, 0), /*  18 :  3 */
-
-  index(2, 1, 0, 0), /*  19 :  3 */
-  index(2, 0, 1, 0), /*  20 :  3 */
-  index(2, 0, 0, 1), /*  21 :  3 */
-  index(0, 2, 1, 0), /*  22 :  3 */
-  index(0, 2, 0, 1), /*  23 :  3 */
-  index(1, 2, 0, 0), /*  24 :  3 */
-  index(0, 0, 2, 1), /*  25 :  3 */
-  index(1, 0, 2, 0), /*  26 :  3 */
-  index(0, 1, 2, 0), /*  27 :  3 */
-  index(1, 0, 0, 2), /*  28 :  3 */
-  index(0, 1, 0, 2), /*  29 :  3 */
-  index(0, 0, 1, 2), /*  30 :  3 */
-
-  index(3, 0, 0, 0), /*  31 :  3 */
-  index(0, 3, 0, 0), /*  32 :  3 */
-  index(0, 0, 3, 0), /*  33 :  3 */
-  index(0, 0, 0, 3), /*  34 :  3 */
-
-  index(1, 1, 1, 1), /*  35 :  4 */
-
-  index(2, 0, 1, 1), /*  36 :  4 */
-  index(2, 1, 0, 1), /*  37 :  4 */
-  index(2, 1, 1, 0), /*  38 :  4 */
-  index(1, 2, 0, 1), /*  39 :  4 */
-  index(1, 2, 1, 0), /*  40 :  4 */
-  index(0, 2, 1, 1), /*  41 :  4 */
-  index(1, 1, 2, 0), /*  42 :  4 */
-  index(0, 1, 2, 1), /*  43 :  4 */
-  index(1, 0, 2, 1), /*  44 :  4 */
-  index(0, 1, 1, 2), /*  45 :  4 */
-  index(1, 0, 1, 2), /*  46 :  4 */
-  index(1, 1, 0, 2), /*  47 :  4 */
-
-  index(2, 2, 0, 0), /*  48 :  4 */
-  index(0, 0, 2, 2), /*  49 :  4 */
-  index(2, 0, 2, 0), /*  50 :  4 */
-  index(0, 2, 0, 2), /*  51 :  4 */
-  index(2, 0, 0, 2), /*  52 :  4 */
-  index(0, 2, 2, 0), /*  53 :  4 */
-
-  index(3, 1, 0, 0), /*  54 :  4 */
-  index(3, 0, 1, 0), /*  55 :  4 */
-  index(3, 0, 0, 1), /*  56 :  4 */
-  index(0, 3, 1, 0), /*  57 :  4 */
-  index(0, 3, 0, 1), /*  58 :  4 */
-  index(1, 3, 0, 0), /*  59 :  4 */
-  index(0, 0, 3, 1), /*  60 :  4 */
-  index(1, 0, 3, 0), /*  61 :  4 */
-  index(0, 1, 3, 0), /*  62 :  4 */
-  index(1, 0, 0, 3), /*  63 :  4 */
-  index(0, 1, 0, 3), /*  64 :  4 */
-  index(0, 0, 1, 3), /*  65 :  4 */
-
-  index(2, 1, 1, 1), /*  66 :  5 */
-  index(1, 2, 1, 1), /*  67 :  5 */
-  index(1, 1, 2, 1), /*  68 :  5 */
-  index(1, 1, 1, 2), /*  69 :  5 */
-
-  index(1, 0, 2, 2), /*  70 :  5 */
-  index(1, 2, 0, 2), /*  71 :  5 */
-  index(1, 2, 2, 0), /*  72 :  5 */
-  index(2, 1, 0, 2), /*  73 :  5 */
-  index(2, 1, 2, 0), /*  74 :  5 */
-  index(0, 1, 2, 2), /*  75 :  5 */
-  index(2, 2, 1, 0), /*  76 :  5 */
-  index(0, 2, 1, 2), /*  77 :  5 */
-  index(2, 0, 1, 2), /*  78 :  5 */
-  index(0, 2, 2, 1), /*  79 :  5 */
-  index(2, 0, 2, 1), /*  80 :  5 */
-  index(2, 2, 0, 1), /*  81 :  5 */
-
-  index(3, 0, 1, 1), /*  82 :  5 */
-  index(3, 1, 0, 1), /*  83 :  5 */
-  index(3, 1, 1, 0), /*  84 :  5 */
-  index(1, 3, 0, 1), /*  85 :  5 */
-  index(1, 3, 1, 0), /*  86 :  5 */
-  index(0, 3, 1, 1), /*  87 :  5 */
-  index(1, 1, 3, 0), /*  88 :  5 */
-  index(0, 1, 3, 1), /*  89 :  5 */
-  index(1, 0, 3, 1), /*  90 :  5 */
-  index(0, 1, 1, 3), /*  91 :  5 */
-  index(1, 0, 1, 3), /*  92 :  5 */
-  index(1, 1, 0, 3), /*  93 :  5 */
-
-  index(3, 2, 0, 0), /*  94 :  5 */
-  index(3, 0, 2, 0), /*  95 :  5 */
-  index(3, 0, 0, 2), /*  96 :  5 */
-  index(0, 3, 2, 0), /*  97 :  5 */
-  index(0, 3, 0, 2), /*  98 :  5 */
-  index(2, 3, 0, 0), /*  99 :  5 */
-  index(0, 0, 3, 2), /* 100 :  5 */
-  index(2, 0, 3, 0), /* 101 :  5 */
-  index(0, 2, 3, 0), /* 102 :  5 */
-  index(2, 0, 0, 3), /* 103 :  5 */
-  index(0, 2, 0, 3), /* 104 :  5 */
-  index(0, 0, 2, 3), /* 105 :  5 */
-
-  index(2, 2, 1, 1), /* 106 :  6 */
-  index(1, 1, 2, 2), /* 107 :  6 */
-  index(2, 1, 2, 1), /* 108 :  6 */
-  index(1, 2, 1, 2), /* 109 :  6 */
-  index(2, 1, 1, 2), /* 110 :  6 */
-  index(1, 2, 2, 1), /* 111 :  6 */
-
-  index(0, 2, 2, 2), /* 112 :  6 */
-  index(2, 0, 2, 2), /* 113 :  6 */
-  index(2, 2, 0, 2), /* 114 :  6 */
-  index(2, 2, 2, 0), /* 115 :  6 */
-
-  index(3, 1, 1, 1), /* 116 :  6 */
-  index(1, 3, 1, 1), /* 117 :  6 */
-  index(1, 1, 3, 1), /* 118 :  6 */
-  index(1, 1, 1, 3), /* 119 :  6 */
-
-  index(3, 2, 1, 0), /* 120 :  6 */
-  index(3, 2, 0, 1), /* 121 :  6 */
-  index(3, 0, 2, 1), /* 122 :  6 */
-  index(3, 1, 2, 0), /* 123 :  6 */
-  index(3, 1, 0, 2), /* 124 :  6 */
-  index(3, 0, 1, 2), /* 125 :  6 */
-  index(0, 3, 2, 1), /* 126 :  6 */
-  index(1, 3, 2, 0), /* 127 :  6 */
-  index(1, 3, 0, 2), /* 128 :  6 */
-  index(0, 3, 1, 2), /* 129 :  6 */
-  index(2, 3, 1, 0), /* 130 :  6 */
-  index(2, 3, 0, 1), /* 131 :  6 */
-  index(1, 0, 3, 2), /* 132 :  6 */
-  index(0, 1, 3, 2), /* 133 :  6 */
-  index(2, 1, 3, 0), /* 134 :  6 */
-  index(2, 0, 3, 1), /* 135 :  6 */
-  index(0, 2, 3, 1), /* 136 :  6 */
-  index(1, 2, 3, 0), /* 137 :  6 */
-  index(2, 1, 0, 3), /* 138 :  6 */
-  index(2, 0, 1, 3), /* 139 :  6 */
-  index(0, 2, 1, 3), /* 140 :  6 */
-  index(1, 2, 0, 3), /* 141 :  6 */
-  index(1, 0, 2, 3), /* 142 :  6 */
-  index(0, 1, 2, 3), /* 143 :  6 */
-
-  index(3, 3, 0, 0), /* 144 :  6 */
-  index(0, 0, 3, 3), /* 145 :  6 */
-  index(3, 0, 3, 0), /* 146 :  6 */
-  index(0, 3, 0, 3), /* 147 :  6 */
-  index(3, 0, 0, 3), /* 148 :  6 */
-  index(0, 3, 3, 0), /* 149 :  6 */
-
-  index(1, 2, 2, 2), /* 150 :  7 */
-  index(2, 1, 2, 2), /* 151 :  7 */
-  index(2, 2, 1, 2), /* 152 :  7 */
-  index(2, 2, 2, 1), /* 153 :  7 */
-
-  index(3, 2, 1, 1), /* 154 :  7 */
-  index(3, 1, 2, 1), /* 155 :  7 */
-  index(3, 1, 1, 2), /* 156 :  7 */
-  index(1, 3, 2, 1), /* 157 :  7 */
-  index(1, 3, 1, 2), /* 158 :  7 */
-  index(2, 3, 1, 1), /* 159 :  7 */
-  index(1, 1, 3, 2), /* 160 :  7 */
-  index(2, 1, 3, 1), /* 161 :  7 */
-  index(1, 2, 3, 1), /* 162 :  7 */
-  index(2, 1, 1, 3), /* 163 :  7 */
-  index(1, 2, 1, 3), /* 164 :  7 */
-  index(1, 1, 2, 3), /* 165 :  7 */
-
-  index(3, 0, 2, 2), /* 166 :  7 */
-  index(3, 2, 0, 2), /* 167 :  7 */
-  index(3, 2, 2, 0), /* 168 :  7 */
-  index(2, 3, 0, 2), /* 169 :  7 */
-  index(2, 3, 2, 0), /* 170 :  7 */
-  index(0, 3, 2, 2), /* 171 :  7 */
-  index(2, 2, 3, 0), /* 172 :  7 */
-  index(0, 2, 3, 2), /* 173 :  7 */
-  index(2, 0, 3, 2), /* 174 :  7 */
-  index(0, 2, 2, 3), /* 175 :  7 */
-  index(2, 0, 2, 3), /* 176 :  7 */
-  index(2, 2, 0, 3), /* 177 :  7 */
-
-  index(1, 0, 3, 3), /* 178 :  7 */
-  index(1, 3, 0, 3), /* 179 :  7 */
-  index(1, 3, 3, 0), /* 180 :  7 */
-  index(3, 1, 0, 3), /* 181 :  7 */
-  index(3, 1, 3, 0), /* 182 :  7 */
-  index(0, 1, 3, 3), /* 183 :  7 */
-  index(3, 3, 1, 0), /* 184 :  7 */
-  index(0, 3, 1, 3), /* 185 :  7 */
-  index(3, 0, 1, 3), /* 186 :  7 */
-  index(0, 3, 3, 1), /* 187 :  7 */
-  index(3, 0, 3, 1), /* 188 :  7 */
-  index(3, 3, 0, 1), /* 189 :  7 */
-
-  index(2, 2, 2, 2), /* 190 :  8 */
-
-  index(3, 1, 2, 2), /* 191 :  8 */
-  index(3, 2, 1, 2), /* 192 :  8 */
-  index(3, 2, 2, 1), /* 193 :  8 */
-  index(2, 3, 1, 2), /* 194 :  8 */
-  index(2, 3, 2, 1), /* 195 :  8 */
-  index(1, 3, 2, 2), /* 196 :  8 */
-  index(2, 2, 3, 1), /* 197 :  8 */
-  index(1, 2, 3, 2), /* 198 :  8 */
-  index(2, 1, 3, 2), /* 199 :  8 */
-  index(1, 2, 2, 3), /* 200 :  8 */
-  index(2, 1, 2, 3), /* 201 :  8 */
-  index(2, 2, 1, 3), /* 202 :  8 */
-
-  index(3, 3, 1, 1), /* 203 :  8 */
-  index(1, 1, 3, 3), /* 204 :  8 */
-  index(3, 1, 3, 1), /* 205 :  8 */
-  index(1, 3, 1, 3), /* 206 :  8 */
-  index(3, 1, 1, 3), /* 207 :  8 */
-  index(1, 3, 3, 1), /* 208 :  8 */
-
-  index(2, 0, 3, 3), /* 209 :  8 */
-  index(2, 3, 0, 3), /* 210 :  8 */
-  index(2, 3, 3, 0), /* 211 :  8 */
-  index(3, 2, 0, 3), /* 212 :  8 */
-  index(3, 2, 3, 0), /* 213 :  8 */
-  index(0, 2, 3, 3), /* 214 :  8 */
-  index(3, 3, 2, 0), /* 215 :  8 */
-  index(0, 3, 2, 3), /* 216 :  8 */
-  index(3, 0, 2, 3), /* 217 :  8 */
-  index(0, 3, 3, 2), /* 218 :  8 */
-  index(3, 0, 3, 2), /* 219 :  8 */
-  index(3, 3, 0, 2), /* 220 :  8 */
-
-  index(3, 2, 2, 2), /* 221 :  9 */
-  index(2, 3, 2, 2), /* 222 :  9 */
-  index(2, 2, 3, 2), /* 223 :  9 */
-  index(2, 2, 2, 3), /* 224 :  9 */
-
-  index(2, 1, 3, 3), /* 225 :  9 */
-  index(2, 3, 1, 3), /* 226 :  9 */
-  index(2, 3, 3, 1), /* 227 :  9 */
-  index(3, 2, 1, 3), /* 228 :  9 */
-  index(3, 2, 3, 1), /* 229 :  9 */
-  index(1, 2, 3, 3), /* 230 :  9 */
-  index(3, 3, 2, 1), /* 231 :  9 */
-  index(1, 3, 2, 3), /* 232 :  9 */
-  index(3, 1, 2, 3), /* 233 :  9 */
-  index(1, 3, 3, 2), /* 234 :  9 */
-  index(3, 1, 3, 2), /* 235 :  9 */
-  index(3, 3, 1, 2), /* 236 :  9 */
-
-  index(0, 3, 3, 3), /* 237 :  9 */
-  index(3, 0, 3, 3), /* 238 :  9 */
-  index(3, 3, 0, 3), /* 239 :  9 */
-  index(3, 3, 3, 0), /* 240 :  9 */
-
-  index(3, 3, 2, 2), /* 241 : 10 */
-  index(2, 2, 3, 3), /* 242 : 10 */
-  index(3, 2, 3, 2), /* 243 : 10 */
-  index(2, 3, 2, 3), /* 244 : 10 */
-  index(3, 2, 2, 3), /* 245 : 10 */
-  index(2, 3, 3, 2), /* 246 : 10 */
-
-  index(1, 3, 3, 3), /* 247 : 10 */
-  index(3, 1, 3, 3), /* 248 : 10 */
-  index(3, 3, 1, 3), /* 249 : 10 */
-  index(3, 3, 3, 1), /* 250 : 10 */
-
-  index(2, 3, 3, 3), /* 251 : 11 */
-  index(3, 2, 3, 3), /* 252 : 11 */
-  index(3, 3, 2, 3), /* 253 : 11 */
-  index(3, 3, 3, 2), /* 254 : 11 */
-
-  index(3, 3, 3, 3), /* 255 : 12 */
-};
-
-#undef index
diff --git a/ThirdParty/zfp/vtkzfp/src/template/codecf.c b/ThirdParty/zfp/vtkzfp/src/template/codecf.c
deleted file mode 100644
index bc2cc8082d252ee81c7a87891a77e76d8698ca35..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/codecf.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <limits.h>
-#include <math.h>
-
-/* maximum number of bit planes to encode */
-static uint
-precision(int maxexp, uint maxprec, int minexp, int dims)
-{
-  return MIN(maxprec, (uint)MAX(0, maxexp - minexp + 2 * (dims + 1)));
-}
-
-/* map integer x relative to exponent e to floating-point number */
-static Scalar
-_t1(dequantize, Scalar)(Int x, int e)
-{
-  return LDEXP((Scalar)x, e - (CHAR_BIT * (int)sizeof(Scalar) - 2));
-}
-
-/* inverse block-floating-point transform from signed integers */
-static void
-_t1(inv_cast, Scalar)(const Int* iblock, Scalar* fblock, uint n, int emax)
-{
-  /* compute power-of-two scale factor s */
-  Scalar s = _t1(dequantize, Scalar)(1, emax);
-  /* compute p-bit float x = s*y where |y| <= 2^(p-2) - 1 */
-  do
-    *fblock++ = (Scalar)(s * *iblock++);
-  while (--n);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/compress.c b/ThirdParty/zfp/vtkzfp/src/template/compress.c
deleted file mode 100644
index 3bef658df6d034b2c9966ee05753f84ff751531a..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/compress.c
+++ /dev/null
@@ -1,109 +0,0 @@
-/* compress 1d contiguous array */
-static void
-_t2(compress, Scalar, 1)(zfp_stream* stream, const zfp_field* field)
-{
-  const Scalar* data = (const Scalar*)field->data;
-  uint nx = field->nx;
-  uint mx = nx & ~3u;
-  uint x;
-
-  /* compress array one block of 4 values at a time */
-  for (x = 0; x < mx; x += 4, data += 4)
-    _t2(zfp_encode_block, Scalar, 1)(stream, data);
-  if (x < nx)
-    _t2(zfp_encode_partial_block_strided, Scalar, 1)(stream, data, nx - x, 1);
-}
-
-/* compress 1d strided array */
-static void
-_t2(compress_strided, Scalar, 1)(zfp_stream* stream, const zfp_field* field)
-{
-  const Scalar* data = field->data;
-  uint nx = field->nx;
-  int sx = field->sx ? field->sx : 1;
-  uint x;
-
-  /* compress array one block of 4 values at a time */
-  for (x = 0; x < nx; x += 4) {
-    const Scalar* p = data + sx * (ptrdiff_t)x;
-    if (nx - x < 4)
-      _t2(zfp_encode_partial_block_strided, Scalar, 1)(stream, p, nx - x, sx);
-    else
-      _t2(zfp_encode_block_strided, Scalar, 1)(stream, p, sx);
-  }
-}
-
-/* compress 2d strided array */
-static void
-_t2(compress_strided, Scalar, 2)(zfp_stream* stream, const zfp_field* field)
-{
-  const Scalar* data = (const Scalar*)field->data;
-  uint nx = field->nx;
-  uint ny = field->ny;
-  int sx = field->sx ? field->sx : 1;
-  int sy = field->sy ? field->sy : (int)nx;
-  uint x, y;
-
-  /* compress array one block of 4x4 values at a time */
-  for (y = 0; y < ny; y += 4)
-    for (x = 0; x < nx; x += 4) {
-      const Scalar* p = data + sx * (ptrdiff_t)x + sy * (ptrdiff_t)y;
-      if (nx - x < 4 || ny - y < 4)
-        _t2(zfp_encode_partial_block_strided, Scalar, 2)(stream, p, MIN(nx - x, 4u), MIN(ny - y, 4u), sx, sy);
-      else
-        _t2(zfp_encode_block_strided, Scalar, 2)(stream, p, sx, sy);
-    }
-}
-
-/* compress 3d strided array */
-static void
-_t2(compress_strided, Scalar, 3)(zfp_stream* stream, const zfp_field* field)
-{
-  const Scalar* data = (const Scalar*)field->data;
-  uint nx = field->nx;
-  uint ny = field->ny;
-  uint nz = field->nz;
-  int sx = field->sx ? field->sx : 1;
-  int sy = field->sy ? field->sy : (int)nx;
-  int sz = field->sz ? field->sz : (int)(nx * ny);
-  uint x, y, z;
-
-  /* compress array one block of 4x4x4 values at a time */
-  for (z = 0; z < nz; z += 4)
-    for (y = 0; y < ny; y += 4)
-      for (x = 0; x < nx; x += 4) {
-        const Scalar* p = data + sx * (ptrdiff_t)x + sy * (ptrdiff_t)y + sz * (ptrdiff_t)z;
-        if (nx - x < 4 || ny - y < 4 || nz - z < 4)
-          _t2(zfp_encode_partial_block_strided, Scalar, 3)(stream, p, MIN(nx - x, 4u), MIN(ny - y, 4u), MIN(nz - z, 4u), sx, sy, sz);
-        else
-          _t2(zfp_encode_block_strided, Scalar, 3)(stream, p, sx, sy, sz);
-      }
-}
-
-/* compress 4d strided array */
-static void
-_t2(compress_strided, Scalar, 4)(zfp_stream* stream, const zfp_field* field)
-{
-  const Scalar* data = field->data;
-  uint nx = field->nx;
-  uint ny = field->ny;
-  uint nz = field->nz;
-  uint nw = field->nw;
-  int sx = field->sx ? field->sx : 1;
-  int sy = field->sy ? field->sy : (int)nx;
-  int sz = field->sz ? field->sz : (int)(nx * ny);
-  int sw = field->sw ? field->sw : (int)(nx * ny * nz);
-  uint x, y, z, w;
-
-  /* compress array one block of 4x4x4x4 values at a time */
-  for (w = 0; w < nw; w += 4)
-    for (z = 0; z < nz; z += 4)
-      for (y = 0; y < ny; y += 4)
-        for (x = 0; x < nx; x += 4) {
-          const Scalar* p = data + sx * (ptrdiff_t)x + sy * (ptrdiff_t)y + sz * (ptrdiff_t)z + sw * (ptrdiff_t)w;
-          if (nx - x < 4 || ny - y < 4 || nz - z < 4 || nw - w < 4)
-            _t2(zfp_encode_partial_block_strided, Scalar, 4)(stream, p, MIN(nx - x, 4u), MIN(ny - y, 4u), MIN(nz - z, 4u), MIN(nw - w, 4u), sx, sy, sz, sw);
-          else
-            _t2(zfp_encode_block_strided, Scalar, 4)(stream, p, sx, sy, sz, sw);
-        }
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/cudacompress.c b/ThirdParty/zfp/vtkzfp/src/template/cudacompress.c
deleted file mode 100644
index 1d685c92f395f87742f1bd5fe4f5776b5b24a5d2..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/cudacompress.c
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifdef ZFP_WITH_CUDA
-
-#include "../cuda_zfp/cuZFP.h"
-
-static void 
-_t2(compress_cuda, Scalar, 1)(zfp_stream* stream, const zfp_field* field)
-{
-  if(zfp_stream_compression_mode(stream) == zfp_mode_fixed_rate)
-  { 
-    cuda_compress(stream, field);   
-  }
-}
-
-/* compress 1d strided array */
-static void 
-_t2(compress_strided_cuda, Scalar, 1)(zfp_stream* stream, const zfp_field* field)
-{
-  if(zfp_stream_compression_mode(stream) == zfp_mode_fixed_rate)
-  {
-    cuda_compress(stream, field);   
-  }
-}
-
-/* compress 2d strided array */
-static void 
-_t2(compress_strided_cuda, Scalar, 2)(zfp_stream* stream, const zfp_field* field)
-{
-  if(zfp_stream_compression_mode(stream) == zfp_mode_fixed_rate)
-  {
-    cuda_compress(stream, field);   
-  }
-}
-
-/* compress 3d strided array */
-static void
-_t2(compress_strided_cuda, Scalar, 3)(zfp_stream* stream, const zfp_field* field)
-{
-  if(zfp_stream_compression_mode(stream) == zfp_mode_fixed_rate)
-  {
-    cuda_compress(stream, field);   
-  }
-}
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/src/template/cudadecompress.c b/ThirdParty/zfp/vtkzfp/src/template/cudadecompress.c
deleted file mode 100644
index 4ea4e5bf04fe0d768f53fabc31ce883ca192dd47..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/cudadecompress.c
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifdef ZFP_WITH_CUDA
-
-#include "../cuda_zfp/cuZFP.h"
-
-static void
-_t2(decompress_cuda, Scalar, 1)(zfp_stream* stream, zfp_field* field)
-{
-  if(zfp_stream_compression_mode(stream) == zfp_mode_fixed_rate)
-  {
-    cuda_decompress(stream, field);   
-  }
-}
-
-/* compress 1d strided array */
-static void
-_t2(decompress_strided_cuda, Scalar, 1)(zfp_stream* stream, zfp_field* field)
-{
-  if(zfp_stream_compression_mode(stream) == zfp_mode_fixed_rate)
-  {
-    cuda_decompress(stream, field);   
-  }
-}
-
-/* compress 2d strided array */
-static void
-_t2(decompress_strided_cuda, Scalar, 2)(zfp_stream* stream, zfp_field* field)
-{
-  if(zfp_stream_compression_mode(stream) == zfp_mode_fixed_rate)
-  {
-    cuda_decompress(stream, field);   
-  }
-}
-
-/* compress 3d strided array */
-static void
-_t2(decompress_strided_cuda, Scalar, 3)(zfp_stream* stream, zfp_field* field)
-{
-  if(zfp_stream_compression_mode(stream) == zfp_mode_fixed_rate)
-  {
-    cuda_decompress(stream, field);   
-  }
-}
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/src/template/decode.c b/ThirdParty/zfp/vtkzfp/src/template/decode.c
deleted file mode 100644
index e2a2f276da0099f3435264621410d0089137bf94..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/decode.c
+++ /dev/null
@@ -1,141 +0,0 @@
-#include <limits.h>
-
-static void _t2(inv_xform, Int, DIMS)(Int* p);
-
-/* private functions ------------------------------------------------------- */
-
-/* inverse lifting transform of 4-vector */
-static void
-_t1(inv_lift, Int)(Int* p, uint s)
-{
-  Int x, y, z, w;
-  x = *p; p += s;
-  y = *p; p += s;
-  z = *p; p += s;
-  w = *p; p += s;
-
-  /*
-  ** non-orthogonal transform
-  **       ( 4  6 -4 -1) (x)
-  ** 1/4 * ( 4  2  4  5) (y)
-  **       ( 4 -2  4 -5) (z)
-  **       ( 4 -6 -4  1) (w)
-  */
-  y += w >> 1; w -= y >> 1;
-  y += w; w <<= 1; w -= y;
-  z += x; x <<= 1; x -= z;
-  y += z; z <<= 1; z -= y;
-  w += x; x <<= 1; x -= w;
-
-  p -= s; *p = w;
-  p -= s; *p = z;
-  p -= s; *p = y;
-  p -= s; *p = x;
-}
-
-/* map two's complement signed integer to negabinary unsigned integer */
-static Int
-_t1(uint2int, UInt)(UInt x)
-{
-  return (Int)((x ^ NBMASK) - NBMASK);
-}
-
-/* reorder unsigned coefficients and convert to signed integer */
-static void
-_t1(inv_order, Int)(const UInt* ublock, Int* iblock, const uchar* perm, uint n)
-{
-  do
-    iblock[*perm++] = _t1(uint2int, UInt)(*ublock++);
-  while (--n);
-}
-
-/* decompress sequence of size unsigned integers */
-static uint
-_t1(decode_ints, UInt)(bitstream* restrict_ stream, uint maxbits, uint maxprec, UInt* restrict_ data, uint size)
-{
-  /* make a copy of bit stream to avoid aliasing */
-  bitstream s = *stream;
-  uint intprec = CHAR_BIT * (uint)sizeof(UInt);
-  uint kmin = intprec > maxprec ? intprec - maxprec : 0;
-  uint bits = maxbits;
-  uint i, k, m, n;
-  uint64 x;
-
-  /* initialize data array to all zeros */
-  for (i = 0; i < size; i++)
-    data[i] = 0;
-
-  /* decode one bit plane at a time from MSB to LSB */
-  for (k = intprec, n = 0; bits && k-- > kmin;) {
-    /* decode first n bits of bit plane #k */
-    m = MIN(n, bits);
-    bits -= m;
-    x = stream_read_bits(&s, m);
-    /* unary run-length decode remainder of bit plane */
-    for (; n < size && bits && (bits--, stream_read_bit(&s)); x += (uint64)1 << n++)
-      for (; n < size - 1 && bits && (bits--, !stream_read_bit(&s)); n++)
-        ;
-    /* deposit bit plane from x */
-    for (i = 0; x; i++, x >>= 1)
-      data[i] += (UInt)(x & 1u) << k;
-  }
-
-  *stream = s;
-  return maxbits - bits;
-}
-
-/* decompress sequence of size > 64 unsigned integers */
-static uint
-_t1(decode_many_ints, UInt)(bitstream* restrict_ stream, uint maxbits, uint maxprec, UInt* restrict_ data, uint size)
-{
-  /* make a copy of bit stream to avoid aliasing */
-  bitstream s = *stream;
-  uint intprec = CHAR_BIT * (uint)sizeof(UInt);
-  uint kmin = intprec > maxprec ? intprec - maxprec : 0;
-  uint bits = maxbits;
-  uint i, k, m, n;
-
-  /* initialize data array to all zeros */
-  for (i = 0; i < size; i++)
-    data[i] = 0;
-
-  /* decode one bit plane at a time from MSB to LSB */
-  for (k = intprec, n = 0; bits && k-- > kmin;) {
-    /* decode first n bits of bit plane #k */
-    m = MIN(n, bits);
-    bits -= m;
-    for (i = 0; i < m; i++)
-      if (stream_read_bit(&s))
-        data[i] += (UInt)1 << k;
-    /* unary run-length decode remainder of bit plane */
-    for (; n < size && bits && (--bits, stream_read_bit(&s)); data[n] += (UInt)1 << k, n++)
-      for (; n < size - 1 && bits && (--bits, !stream_read_bit(&s)); n++)
-        ;
-  }
-
-  *stream = s;
-  return maxbits - bits;
-}
-
-/* decode block of integers */
-static uint
-_t2(decode_block, Int, DIMS)(bitstream* stream, int minbits, int maxbits, int maxprec, Int* iblock)
-{
-  int bits;
-  cache_align_(UInt ublock[BLOCK_SIZE]);
-  /* decode integer coefficients */
-  if (BLOCK_SIZE <= 64)
-    bits = _t1(decode_ints, UInt)(stream, maxbits, maxprec, ublock, BLOCK_SIZE);
-  else
-    bits = _t1(decode_many_ints, UInt)(stream, maxbits, maxprec, ublock, BLOCK_SIZE);
-  /* read at least minbits bits */
-  if (bits < minbits) {
-    stream_skip(stream, minbits - bits);
-    bits = minbits;
-  }
-  /* reorder unsigned coefficients and convert to signed integer */
-  _t1(inv_order, Int)(ublock, iblock, PERM, BLOCK_SIZE);
-  /* perform decorrelating transform */
-  _t2(inv_xform, Int, DIMS)(iblock);
-  return bits;
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/decode1.c b/ThirdParty/zfp/vtkzfp/src/template/decode1.c
deleted file mode 100644
index 68ee0793e82a64c4733d59c255255c7588e3b424..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/decode1.c
+++ /dev/null
@@ -1,53 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* scatter 4-value block to strided array */
-static void
-_t2(scatter, Scalar, 1)(const Scalar* q, Scalar* p, int sx)
-{
-  uint x;
-  for (x = 0; x < 4; x++, p += sx)
-    *p = *q++;
-}
-
-/* scatter nx-value block to strided array */
-static void
-_t2(scatter_partial, Scalar, 1)(const Scalar* q, Scalar* p, uint nx, int sx)
-{
-  uint x;
-  for (x = 0; x < nx; x++, p += sx)
-   *p = *q++;
-}
-
-/* inverse decorrelating 1D transform */
-static void
-_t2(inv_xform, Int, 1)(Int* p)
-{
-  /* transform along x */
-  _t1(inv_lift, Int)(p, 1);
-}
-
-/* public functions -------------------------------------------------------- */
-
-/* decode 4-value floating-point block and store at p using stride sx */
-uint
-_t2(zfp_decode_block_strided, Scalar, 1)(zfp_stream* stream, Scalar* p, int sx)
-{
-  /* decode contiguous block */
-  cache_align_(Scalar fblock[4]);
-  uint bits = _t2(zfp_decode_block, Scalar, 1)(stream, fblock);
-  /* scatter block to strided array */
-  _t2(scatter, Scalar, 1)(fblock, p, sx);
-  return bits;
-}
-
-/* decode nx-value floating-point block and store at p using stride sx */
-uint
-_t2(zfp_decode_partial_block_strided, Scalar, 1)(zfp_stream* stream, Scalar* p, uint nx, int sx)
-{
-  /* decode contiguous block */
-  cache_align_(Scalar fblock[4]);
-  uint bits = _t2(zfp_decode_block, Scalar, 1)(stream, fblock);
-  /* scatter block to strided array */
-  _t2(scatter_partial, Scalar, 1)(fblock, p, nx, sx);
-  return bits;
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/decode2.c b/ThirdParty/zfp/vtkzfp/src/template/decode2.c
deleted file mode 100644
index 23e1892cb5726a1483eccd86e81206f62820ea28..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/decode2.c
+++ /dev/null
@@ -1,60 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* scatter 4*4 block to strided array */
-static void
-_t2(scatter, Scalar, 2)(const Scalar* q, Scalar* p, int sx, int sy)
-{
-  uint x, y;
-  for (y = 0; y < 4; y++, p += sy - 4 * sx)
-    for (x = 0; x < 4; x++, p += sx)
-      *p = *q++;
-}
-
-/* scatter nx*ny block to strided array */
-static void
-_t2(scatter_partial, Scalar, 2)(const Scalar* q, Scalar* p, uint nx, uint ny, int sx, int sy)
-{
-  uint x, y;
-  for (y = 0; y < ny; y++, p += sy - (ptrdiff_t)nx * sx, q += 4 - nx)
-    for (x = 0; x < nx; x++, p += sx, q++)
-      *p = *q;
-}
-
-/* inverse decorrelating 2D transform */
-static void
-_t2(inv_xform, Int, 2)(Int* p)
-{
-  uint x, y;
-  /* transform along y */
-  for (x = 0; x < 4; x++)
-    _t1(inv_lift, Int)(p + 1 * x, 4);
-  /* transform along x */
-  for (y = 0; y < 4; y++)
-    _t1(inv_lift, Int)(p + 4 * y, 1);
-}
-
-/* public functions -------------------------------------------------------- */
-
-/* decode 4*4 floating-point block and store at p using strides (sx, sy) */
-uint
-_t2(zfp_decode_block_strided, Scalar, 2)(zfp_stream* stream, Scalar* p, int sx, int sy)
-{
-  /* decode contiguous block */
-  cache_align_(Scalar fblock[16]);
-  uint bits = _t2(zfp_decode_block, Scalar, 2)(stream, fblock);
-  /* scatter block to strided array */
-  _t2(scatter, Scalar, 2)(fblock, p, sx, sy);
-  return bits;
-}
-
-/* decode nx*ny floating-point block and store at p using strides (sx, sy) */
-uint
-_t2(zfp_decode_partial_block_strided, Scalar, 2)(zfp_stream* stream, Scalar* p, uint nx, uint ny, int sx, int sy)
-{
-  /* decode contiguous block */
-  cache_align_(Scalar fblock[16]);
-  uint bits = _t2(zfp_decode_block, Scalar, 2)(stream, fblock);
-  /* scatter block to strided array */
-  _t2(scatter_partial, Scalar, 2)(fblock, p, nx, ny, sx, sy);
-  return bits;
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/decode3.c b/ThirdParty/zfp/vtkzfp/src/template/decode3.c
deleted file mode 100644
index b48411821f1cfeb8be349d15645e6a137ec20a42..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/decode3.c
+++ /dev/null
@@ -1,68 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* scatter 4*4*4 block to strided array */
-static void
-_t2(scatter, Scalar, 3)(const Scalar* q, Scalar* p, int sx, int sy, int sz)
-{
-  uint x, y, z;
-  for (z = 0; z < 4; z++, p += sz - 4 * sy)
-    for (y = 0; y < 4; y++, p += sy - 4 * sx)
-      for (x = 0; x < 4; x++, p += sx)
-        *p = *q++;
-}
-
-/* scatter nx*ny*nz block to strided array */
-static void
-_t2(scatter_partial, Scalar, 3)(const Scalar* q, Scalar* p, uint nx, uint ny, uint nz, int sx, int sy, int sz)
-{
-  uint x, y, z;
-  for (z = 0; z < nz; z++, p += sz - (ptrdiff_t)ny * sy, q += 4 * (4 - ny))
-    for (y = 0; y < ny; y++, p += sy - (ptrdiff_t)nx * sx, q += 1 * (4 - nx))
-      for (x = 0; x < nx; x++, p += sx, q++)
-        *p = *q;
-}
-
-/* inverse decorrelating 3D transform */
-static void
-_t2(inv_xform, Int, 3)(Int* p)
-{
-  uint x, y, z;
-  /* transform along z */
-  for (y = 0; y < 4; y++)
-    for (x = 0; x < 4; x++)
-      _t1(inv_lift, Int)(p + 1 * x + 4 * y, 16);
-  /* transform along y */
-  for (x = 0; x < 4; x++)
-    for (z = 0; z < 4; z++)
-      _t1(inv_lift, Int)(p + 16 * z + 1 * x, 4);
-  /* transform along x */
-  for (z = 0; z < 4; z++)
-    for (y = 0; y < 4; y++)
-      _t1(inv_lift, Int)(p + 4 * y + 16 * z, 1);
-}
-
-/* public functions -------------------------------------------------------- */
-
-/* decode 4*4*4 floating-point block and store at p using strides (sx, sy, sz) */
-uint
-_t2(zfp_decode_block_strided, Scalar, 3)(zfp_stream* stream, Scalar* p, int sx, int sy, int sz)
-{
-  /* decode contiguous block */
-  cache_align_(Scalar fblock[64]);
-  uint bits = _t2(zfp_decode_block, Scalar, 3)(stream, fblock);
-  /* scatter block to strided array */
-  _t2(scatter, Scalar, 3)(fblock, p, sx, sy, sz);
-  return bits;
-}
-
-/* decode nx*ny*nz floating-point block and store at p using strides (sx, sy, sz) */
-uint
-_t2(zfp_decode_partial_block_strided, Scalar, 3)(zfp_stream* stream, Scalar* p, uint nx, uint ny, uint nz, int sx, int sy, int sz)
-{
-  /* decode contiguous block */
-  cache_align_(Scalar fblock[64]);
-  uint bits = _t2(zfp_decode_block, Scalar, 3)(stream, fblock);
-  /* scatter block to strided array */
-  _t2(scatter_partial, Scalar, 3)(fblock, p, nx, ny, nz, sx, sy, sz);
-  return bits;
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/decode4.c b/ThirdParty/zfp/vtkzfp/src/template/decode4.c
deleted file mode 100644
index 8d34abfce25c99ba326da7bfbb8ba68a59830f10..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/decode4.c
+++ /dev/null
@@ -1,78 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* scatter 4*4*4*4 block to strided array */
-static void
-_t2(scatter, Scalar, 4)(const Scalar* q, Scalar* p, int sx, int sy, int sz, int sw)
-{
-  uint x, y, z, w;
-  for (w = 0; w < 4; w++, p += sw - 4 * sz)
-    for (z = 0; z < 4; z++, p += sz - 4 * sy)
-      for (y = 0; y < 4; y++, p += sy - 4 * sx)
-        for (x = 0; x < 4; x++, p += sx)
-          *p = *q++;
-}
-
-/* scatter nx*ny*nz*nw block to strided array */
-static void
-_t2(scatter_partial, Scalar, 4)(const Scalar* q, Scalar* p, uint nx, uint ny, uint nz, uint nw, int sx, int sy, int sz, int sw)
-{
-  uint x, y, z, w;
-  for (w = 0; w < nw; w++, p += sw - (ptrdiff_t)nz * sz, q += 16 * (4 - nz))
-    for (z = 0; z < nz; z++, p += sz - (ptrdiff_t)ny * sy, q += 4 * (4 - ny))
-      for (y = 0; y < ny; y++, p += sy - (ptrdiff_t)nx * sx, q += 1 * (4 - nx))
-        for (x = 0; x < nx; x++, p += sx, q++)
-          *p = *q;
-}
-
-/* inverse decorrelating 4D transform */
-static void
-_t2(inv_xform, Int, 4)(Int* p)
-{
-  uint x, y, z, w;
-  /* transform along w */
-  for (z = 0; z < 4; z++)
-    for (y = 0; y < 4; y++)
-      for (x = 0; x < 4; x++)
-        _t1(inv_lift, Int)(p + 1 * x + 4 * y + 16 * z, 64);
-  /* transform along z */
-  for (y = 0; y < 4; y++)
-    for (x = 0; x < 4; x++)
-      for (w = 0; w < 4; w++)
-        _t1(inv_lift, Int)(p + 64 * w + 1 * x + 4 * y, 16);
-  /* transform along y */
-  for (x = 0; x < 4; x++)
-    for (w = 0; w < 4; w++)
-      for (z = 0; z < 4; z++)
-        _t1(inv_lift, Int)(p + 16 * z + 64 * w + 1 * x, 4);
-  /* transform along x */
-  for (w = 0; w < 4; w++)
-    for (z = 0; z < 4; z++)
-      for (y = 0; y < 4; y++)
-        _t1(inv_lift, Int)(p + 4 * y + 16 * z + 64 * w, 1);
-}
-
-/* public functions -------------------------------------------------------- */
-
-/* decode 4*4*4*4 floating-point block and store at p using strides (sx, sy, sz, sw) */
-uint
-_t2(zfp_decode_block_strided, Scalar, 4)(zfp_stream* stream, Scalar* p, int sx, int sy, int sz, int sw)
-{
-  /* decode contiguous block */
-  cache_align_(Scalar fblock[256]);
-  uint bits = _t2(zfp_decode_block, Scalar, 4)(stream, fblock);
-  /* scatter block to strided array */
-  _t2(scatter, Scalar, 4)(fblock, p, sx, sy, sz, sw);
-  return bits;
-}
-
-/* decode nx*ny*nz*nw floating-point block and store at p using strides (sx, sy, sz, sw) */
-uint
-_t2(zfp_decode_partial_block_strided, Scalar, 4)(zfp_stream* stream, Scalar* p, uint nx, uint ny, uint nz, uint nw, int sx, int sy, int sz, int sw)
-{
-  /* decode contiguous block */
-  cache_align_(Scalar fblock[256]);
-  uint bits = _t2(zfp_decode_block, Scalar, 4)(stream, fblock);
-  /* scatter block to strided array */
-  _t2(scatter_partial, Scalar, 4)(fblock, p, nx, ny, nz, nw, sx, sy, sz, sw);
-  return bits;
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/decodef.c b/ThirdParty/zfp/vtkzfp/src/template/decodef.c
deleted file mode 100644
index 5df156381c1b35033f2c93aaebe3992e4247cb8f..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/decodef.c
+++ /dev/null
@@ -1,42 +0,0 @@
-static uint _t2(rev_decode_block, Scalar, DIMS)(zfp_stream* zfp, Scalar* fblock);
-
-/* private functions ------------------------------------------------------- */
-
-/* decode contiguous floating-point block using lossy algorithm */
-static uint
-_t2(decode_block, Scalar, DIMS)(zfp_stream* zfp, Scalar* fblock)
-{
-  uint bits = 1;
-  /* test if block has nonzero values */
-  if (stream_read_bit(zfp->stream)) {
-    cache_align_(Int iblock[BLOCK_SIZE]);
-    /* decode common exponent */
-    bits += EBITS;
-    int emax = (int)stream_read_bits(zfp->stream, EBITS) - EBIAS;
-    int maxprec = precision(emax, zfp->maxprec, zfp->minexp, DIMS);
-    /* decode integer block */
-    bits += _t2(decode_block, Int, DIMS)(zfp->stream, zfp->minbits - bits, zfp->maxbits - bits, maxprec, iblock);
-    /* perform inverse block-floating-point transform */
-    _t1(inv_cast, Scalar)(iblock, fblock, BLOCK_SIZE, emax);
-  }
-  else {
-    /* set all values to zero */
-    uint i;
-    for (i = 0; i < BLOCK_SIZE; i++)
-      *fblock++ = 0;
-    if (zfp->minbits > bits) {
-      stream_skip(zfp->stream, zfp->minbits - bits);
-      bits = zfp->minbits;
-    }
-  }
-  return bits;
-}
-
-/* public functions -------------------------------------------------------- */
-
-/* decode contiguous floating-point block */
-uint
-_t2(zfp_decode_block, Scalar, DIMS)(zfp_stream* zfp, Scalar* fblock)
-{
-  return REVERSIBLE(zfp) ? _t2(rev_decode_block, Scalar, DIMS)(zfp, fblock) : _t2(decode_block, Scalar, DIMS)(zfp, fblock);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/decodei.c b/ThirdParty/zfp/vtkzfp/src/template/decodei.c
deleted file mode 100644
index 12f62a980f5cd18b9a3a4bd9fa1389b18b87e97c..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/decodei.c
+++ /dev/null
@@ -1,10 +0,0 @@
-static uint _t2(rev_decode_block, Int, DIMS)(bitstream* stream, int minbits, int maxbits, Int* iblock);
-
-/* public functions -------------------------------------------------------- */
-
-/* decode contiguous integer block */
-uint
-_t2(zfp_decode_block, Int, DIMS)(zfp_stream* zfp, Int* iblock)
-{
-  return REVERSIBLE(zfp) ? _t2(rev_decode_block, Int, DIMS)(zfp->stream, zfp->minbits, zfp->maxbits, iblock) : _t2(decode_block, Int, DIMS)(zfp->stream, zfp->minbits, zfp->maxbits, zfp->maxprec, iblock);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/decompress.c b/ThirdParty/zfp/vtkzfp/src/template/decompress.c
deleted file mode 100644
index 22313f81da3436554f6488874e3624dddc5163ee..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/decompress.c
+++ /dev/null
@@ -1,109 +0,0 @@
-/* decompress 1d contiguous array */
-static void
-_t2(decompress, Scalar, 1)(zfp_stream* stream, zfp_field* field)
-{
-  Scalar* data = (Scalar*)field->data;
-  uint nx = field->nx;
-  uint mx = nx & ~3u;
-  uint x;
-
-  /* decompress array one block of 4 values at a time */
-  for (x = 0; x < mx; x += 4, data += 4)
-    _t2(zfp_decode_block, Scalar, 1)(stream, data);
-  if (x < nx)
-    _t2(zfp_decode_partial_block_strided, Scalar, 1)(stream, data, nx - x, 1);
-}
-
-/* decompress 1d strided array */
-static void
-_t2(decompress_strided, Scalar, 1)(zfp_stream* stream, zfp_field* field)
-{
-  Scalar* data = field->data;
-  uint nx = field->nx;
-  int sx = field->sx ? field->sx : 1;
-  uint x;
-
-  /* decompress array one block of 4 values at a time */
-  for (x = 0; x < nx; x += 4) {
-    Scalar* p = data + sx * (ptrdiff_t)x;
-    if (nx - x < 4)
-      _t2(zfp_decode_partial_block_strided, Scalar, 1)(stream, p, nx - x, sx);
-    else
-      _t2(zfp_decode_block_strided, Scalar, 1)(stream, p, sx);
-  }
-}
-
-/* decompress 2d strided array */
-static void
-_t2(decompress_strided, Scalar, 2)(zfp_stream* stream, zfp_field* field)
-{
-  Scalar* data = (Scalar*)field->data;
-  uint nx = field->nx;
-  uint ny = field->ny;
-  int sx = field->sx ? field->sx : 1;
-  int sy = field->sy ? field->sy : (int)nx;
-  uint x, y;
-
-  /* decompress array one block of 4x4 values at a time */
-  for (y = 0; y < ny; y += 4)
-    for (x = 0; x < nx; x += 4) {
-      Scalar* p = data + sx * (ptrdiff_t)x + sy * (ptrdiff_t)y;
-      if (nx - x < 4 || ny - y < 4)
-        _t2(zfp_decode_partial_block_strided, Scalar, 2)(stream, p, MIN(nx - x, 4u), MIN(ny - y, 4u), sx, sy);
-      else
-        _t2(zfp_decode_block_strided, Scalar, 2)(stream, p, sx, sy);
-    }
-}
-
-/* decompress 3d strided array */
-static void
-_t2(decompress_strided, Scalar, 3)(zfp_stream* stream, zfp_field* field)
-{
-  Scalar* data = (Scalar*)field->data;
-  uint nx = field->nx;
-  uint ny = field->ny;
-  uint nz = field->nz;
-  int sx = field->sx ? field->sx : 1;
-  int sy = field->sy ? field->sy : (int)nx;
-  int sz = field->sz ? field->sz : (int)(nx * ny);
-  uint x, y, z;
-
-  /* decompress array one block of 4x4x4 values at a time */
-  for (z = 0; z < nz; z += 4)
-    for (y = 0; y < ny; y += 4)
-      for (x = 0; x < nx; x += 4) {
-        Scalar* p = data + sx * (ptrdiff_t)x + sy * (ptrdiff_t)y + sz * (ptrdiff_t)z;
-        if (nx - x < 4 || ny - y < 4 || nz - z < 4)
-          _t2(zfp_decode_partial_block_strided, Scalar, 3)(stream, p, MIN(nx - x, 4u), MIN(ny - y, 4u), MIN(nz - z, 4u), sx, sy, sz);
-        else
-          _t2(zfp_decode_block_strided, Scalar, 3)(stream, p, sx, sy, sz);
-      }
-}
-
-/* decompress 4d strided array */
-static void
-_t2(decompress_strided, Scalar, 4)(zfp_stream* stream, zfp_field* field)
-{
-  Scalar* data = field->data;
-  uint nx = field->nx;
-  uint ny = field->ny;
-  uint nz = field->nz;
-  uint nw = field->nw;
-  int sx = field->sx ? field->sx : 1;
-  int sy = field->sy ? field->sy : (int)nx;
-  int sz = field->sz ? field->sz : (int)(nx * ny);
-  int sw = field->sw ? field->sw : (int)(nx * ny * nz);
-  uint x, y, z, w;
-
-  /* decompress array one block of 4x4x4x4 values at a time */
-  for (w = 0; w < nw; w += 4)
-    for (z = 0; z < nz; z += 4)
-      for (y = 0; y < ny; y += 4)
-        for (x = 0; x < nx; x += 4) {
-          Scalar* p = data + sx * (ptrdiff_t)x + sy * (ptrdiff_t)y + sz * (ptrdiff_t)z + sw * (ptrdiff_t)w;
-          if (nx - x < 4 || ny - y < 4 || nz - z < 4 || nw - w < 4)
-            _t2(zfp_decode_partial_block_strided, Scalar, 4)(stream, p, MIN(nx - x, 4u), MIN(ny - y, 4u), MIN(nz - z, 4u), MIN(nw - w, 4u), sx, sy, sz, sw);
-          else
-            _t2(zfp_decode_block_strided, Scalar, 4)(stream, p, sx, sy, sz, sw);
-        }
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/encode.c b/ThirdParty/zfp/vtkzfp/src/template/encode.c
deleted file mode 100644
index bba18f60dc6b644ae0f48f3a6ca229af0150e30e..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/encode.c
+++ /dev/null
@@ -1,159 +0,0 @@
-#include <limits.h>
-
-static void _t2(fwd_xform, Int, DIMS)(Int* p);
-
-/* private functions ------------------------------------------------------- */
-
-/* pad partial block of width n <= 4 and stride s */
-static void
-_t1(pad_block, Scalar)(Scalar* p, uint n, uint s)
-{
-  switch (n) {
-    case 0:
-      p[0 * s] = 0;
-      /* FALLTHROUGH */
-    case 1:
-      p[1 * s] = p[0 * s];
-      /* FALLTHROUGH */
-    case 2:
-      p[2 * s] = p[1 * s];
-      /* FALLTHROUGH */
-    case 3:
-      p[3 * s] = p[0 * s];
-      /* FALLTHROUGH */
-    default:
-      break;
-  }
-}
-
-/* forward lifting transform of 4-vector */
-static void
-_t1(fwd_lift, Int)(Int* p, uint s)
-{
-  Int x, y, z, w;
-  x = *p; p += s;
-  y = *p; p += s;
-  z = *p; p += s;
-  w = *p; p += s;
-
-  /*
-  ** non-orthogonal transform
-  **        ( 4  4  4  4) (x)
-  ** 1/16 * ( 5  1 -1 -5) (y)
-  **        (-4  4  4 -4) (z)
-  **        (-2  6 -6  2) (w)
-  */
-  x += w; x >>= 1; w -= x;
-  z += y; z >>= 1; y -= z;
-  x += z; x >>= 1; z -= x;
-  w += y; w >>= 1; y -= w;
-  w += y >> 1; y -= w >> 1;
-
-  p -= s; *p = w;
-  p -= s; *p = z;
-  p -= s; *p = y;
-  p -= s; *p = x;
-}
-
-/* map two's complement signed integer to negabinary unsigned integer */
-static UInt
-_t1(int2uint, Int)(Int x)
-{
-  return ((UInt)x + NBMASK) ^ NBMASK;
-}
-
-/* reorder signed coefficients and convert to unsigned integer */
-static void
-_t1(fwd_order, Int)(UInt* ublock, const Int* iblock, const uchar* perm, uint n)
-{
-  do
-    *ublock++ = _t1(int2uint, Int)(iblock[*perm++]);
-  while (--n);
-}
-
-/* compress sequence of size unsigned integers */
-static uint
-_t1(encode_ints, UInt)(bitstream* restrict_ stream, uint maxbits, uint maxprec, const UInt* restrict_ data, uint size)
-{
-  /* make a copy of bit stream to avoid aliasing */
-  bitstream s = *stream;
-  uint intprec = CHAR_BIT * (uint)sizeof(UInt);
-  uint kmin = intprec > maxprec ? intprec - maxprec : 0;
-  uint bits = maxbits;
-  uint i, k, m, n;
-  uint64 x;
-
-  /* encode one bit plane at a time from MSB to LSB */
-  for (k = intprec, n = 0; bits && k-- > kmin;) {
-    /* step 1: extract bit plane #k to x */
-    x = 0;
-    for (i = 0; i < size; i++)
-      x += (uint64)((data[i] >> k) & 1u) << i;
-    /* step 2: encode first n bits of bit plane */
-    m = MIN(n, bits);
-    bits -= m;
-    x = stream_write_bits(&s, x, m);
-    /* step 3: unary run-length encode remainder of bit plane */
-    for (; n < size && bits && (bits--, stream_write_bit(&s, !!x)); x >>= 1, n++)
-      for (; n < size - 1 && bits && (bits--, !stream_write_bit(&s, x & 1u)); x >>= 1, n++)
-        ;
-  }
-
-  *stream = s;
-  return maxbits - bits;
-}
-
-/* compress sequence of size > 64 unsigned integers */
-static uint
-_t1(encode_many_ints, UInt)(bitstream* restrict_ stream, uint maxbits, uint maxprec, const UInt* restrict_ data, uint size)
-{
-  /* make a copy of bit stream to avoid aliasing */
-  bitstream s = *stream;
-  uint intprec = CHAR_BIT * (uint)sizeof(UInt);
-  uint kmin = intprec > maxprec ? intprec - maxprec : 0;
-  uint bits = maxbits;
-  uint i, k, m, n, c;
-
-  /* encode one bit plane at a time from MSB to LSB */
-  for (k = intprec, n = 0; bits && k-- > kmin;) {
-    /* step 1: encode first n bits of bit plane #k */
-    m = MIN(n, bits);
-    bits -= m;
-    for (i = 0; i < m; i++)
-      stream_write_bit(&s, (data[i] >> k) & 1u);
-    /* step 2: count remaining one-bits in bit plane */
-    c = 0;
-    for (i = m; i < size; i++)
-      c += (data[i] >> k) & 1u;
-    /* step 3: unary run-length encode remainder of bit plane */
-    for (; n < size && bits && (--bits, stream_write_bit(&s, !!c)); c--, n++)
-      for (; n < size - 1 && bits && (--bits, !stream_write_bit(&s, (data[n] >> k) & 1u)); n++)
-        ;
-  }
-
-  *stream = s;
-  return maxbits - bits;
-}
-
-/* encode block of integers */
-static uint
-_t2(encode_block, Int, DIMS)(bitstream* stream, int minbits, int maxbits, int maxprec, Int* iblock)
-{
-  int bits;
-  cache_align_(UInt ublock[BLOCK_SIZE]);
-  /* perform decorrelating transform */
-  _t2(fwd_xform, Int, DIMS)(iblock);
-  /* reorder signed coefficients and convert to unsigned integer */
-  _t1(fwd_order, Int)(ublock, iblock, PERM, BLOCK_SIZE);
-  /* encode integer coefficients */
-  if (BLOCK_SIZE <= 64)
-    bits = _t1(encode_ints, UInt)(stream, maxbits, maxprec, ublock, BLOCK_SIZE);
-  else
-    bits = _t1(encode_many_ints, UInt)(stream, maxbits, maxprec, ublock, BLOCK_SIZE);
-  /* write at least minbits bits by padding with zeros */
-  if (bits < minbits) {
-    stream_pad(stream, minbits - bits);
-    bits = minbits;
-  }
-  return bits;
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/encode1.c b/ThirdParty/zfp/vtkzfp/src/template/encode1.c
deleted file mode 100644
index c61849299a4ffbcde0c99ee7b5c90546cfcc3c9c..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/encode1.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* gather 4-value block from strided array */
-static void
-_t2(gather, Scalar, 1)(Scalar* q, const Scalar* p, int sx)
-{
-  uint x;
-  for (x = 0; x < 4; x++, p += sx)
-    *q++ = *p;
-}
-
-/* gather nx-value block from strided array */
-static void
-_t2(gather_partial, Scalar, 1)(Scalar* q, const Scalar* p, uint nx, int sx)
-{
-  uint x;
-  for (x = 0; x < nx; x++, p += sx)
-    q[x] = *p;
-  _t1(pad_block, Scalar)(q, nx, 1);
-}
-
-/* forward decorrelating 1D transform */
-static void
-_t2(fwd_xform, Int, 1)(Int* p)
-{
-  /* transform along x */
-  _t1(fwd_lift, Int)(p, 1);
-}
-
-/* public functions -------------------------------------------------------- */
-
-/* encode 4-value floating-point block stored at p using stride sx */
-uint
-_t2(zfp_encode_block_strided, Scalar, 1)(zfp_stream* stream, const Scalar* p, int sx)
-{
-  /* gather block from strided array */
-  cache_align_(Scalar fblock[4]);
-  _t2(gather, Scalar, 1)(fblock, p, sx);
-  /* encode floating-point block */
-  return _t2(zfp_encode_block, Scalar, 1)(stream, fblock);
-}
-
-/* encode nx-value floating-point block stored at p using stride sx */
-uint
-_t2(zfp_encode_partial_block_strided, Scalar, 1)(zfp_stream* stream, const Scalar* p, uint nx, int sx)
-{
-  /* gather block from strided array */
-  cache_align_(Scalar fblock[4]);
-  _t2(gather_partial, Scalar, 1)(fblock, p, nx, sx);
-  /* encode floating-point block */
-  return _t2(zfp_encode_block, Scalar, 1)(stream, fblock);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/encode2.c b/ThirdParty/zfp/vtkzfp/src/template/encode2.c
deleted file mode 100644
index 4bec256a630c54e700c43e909bd6e479dbf5baf4..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/encode2.c
+++ /dev/null
@@ -1,62 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* gather 4*4 block from strided array */
-static void
-_t2(gather, Scalar, 2)(Scalar* q, const Scalar* p, int sx, int sy)
-{
-  uint x, y;
-  for (y = 0; y < 4; y++, p += sy - 4 * sx)
-    for (x = 0; x < 4; x++, p += sx)
-      *q++ = *p;
-}
-
-/* gather nx*ny block from strided array */
-static void
-_t2(gather_partial, Scalar, 2)(Scalar* q, const Scalar* p, uint nx, uint ny, int sx, int sy)
-{
-  uint x, y;
-  for (y = 0; y < ny; y++, p += sy - (ptrdiff_t)nx * sx) {
-    for (x = 0; x < nx; x++, p += sx)
-      q[4 * y + x] = *p;
-    _t1(pad_block, Scalar)(q + 4 * y, nx, 1);
-  }
-  for (x = 0; x < 4; x++)
-    _t1(pad_block, Scalar)(q + x, ny, 4);
-}
-
-/* forward decorrelating 2D transform */
-static void
-_t2(fwd_xform, Int, 2)(Int* p)
-{
-  uint x, y;
-  /* transform along x */
-  for (y = 0; y < 4; y++)
-    _t1(fwd_lift, Int)(p + 4 * y, 1);
-  /* transform along y */
-  for (x = 0; x < 4; x++)
-    _t1(fwd_lift, Int)(p + 1 * x, 4);
-}
-
-/* public functions -------------------------------------------------------- */
-
-/* encode 4*4 floating-point block stored at p using strides (sx, sy) */
-uint
-_t2(zfp_encode_block_strided, Scalar, 2)(zfp_stream* stream, const Scalar* p, int sx, int sy)
-{
-  /* gather block from strided array */
-  cache_align_(Scalar fblock[16]);
-  _t2(gather, Scalar, 2)(fblock, p, sx, sy);
-  /* encode floating-point block */
-  return _t2(zfp_encode_block, Scalar, 2)(stream, fblock);
-}
-
-/* encode nx*ny floating-point block stored at p using strides (sx, sy) */
-uint
-_t2(zfp_encode_partial_block_strided, Scalar, 2)(zfp_stream* stream, const Scalar* p, uint nx, uint ny, int sx, int sy)
-{
-  /* gather block from strided array */
-  cache_align_(Scalar fblock[16]);
-  _t2(gather_partial, Scalar, 2)(fblock, p, nx, ny, sx, sy);
-  /* encode floating-point block */
-  return _t2(zfp_encode_block, Scalar, 2)(stream, fblock);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/encode3.c b/ThirdParty/zfp/vtkzfp/src/template/encode3.c
deleted file mode 100644
index a16a8add97dd5f3ecd3036982f384f68d9b4dfb3..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/encode3.c
+++ /dev/null
@@ -1,74 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* gather 4*4*4 block from strided array */
-static void
-_t2(gather, Scalar, 3)(Scalar* q, const Scalar* p, int sx, int sy, int sz)
-{
-  uint x, y, z;
-  for (z = 0; z < 4; z++, p += sz - 4 * sy)
-    for (y = 0; y < 4; y++, p += sy - 4 * sx)
-      for (x = 0; x < 4; x++, p += sx)
-        *q++ = *p;
-}
-
-/* gather nx*ny*nz block from strided array */
-static void
-_t2(gather_partial, Scalar, 3)(Scalar* q, const Scalar* p, uint nx, uint ny, uint nz, int sx, int sy, int sz)
-{
-  uint x, y, z;
-  for (z = 0; z < nz; z++, p += sz - (ptrdiff_t)ny * sy) {
-    for (y = 0; y < ny; y++, p += sy - (ptrdiff_t)nx * sx) {
-      for (x = 0; x < nx; x++, p += sx)
-        q[16 * z + 4 * y + x] = *p; 
-      _t1(pad_block, Scalar)(q + 16 * z + 4 * y, nx, 1);
-    }
-    for (x = 0; x < 4; x++)
-      _t1(pad_block, Scalar)(q + 16 * z + x, ny, 4);
-  }
-  for (y = 0; y < 4; y++)
-    for (x = 0; x < 4; x++)
-      _t1(pad_block, Scalar)(q + 4 * y + x, nz, 16);
-}
-
-/* forward decorrelating 3D transform */
-static void
-_t2(fwd_xform, Int, 3)(Int* p)
-{
-  uint x, y, z;
-  /* transform along x */
-  for (z = 0; z < 4; z++)
-    for (y = 0; y < 4; y++)
-      _t1(fwd_lift, Int)(p + 4 * y + 16 * z, 1);
-  /* transform along y */
-  for (x = 0; x < 4; x++)
-    for (z = 0; z < 4; z++)
-      _t1(fwd_lift, Int)(p + 16 * z + 1 * x, 4);
-  /* transform along z */
-  for (y = 0; y < 4; y++)
-    for (x = 0; x < 4; x++)
-      _t1(fwd_lift, Int)(p + 1 * x + 4 * y, 16);
-}
-
-/* public functions -------------------------------------------------------- */
-
-/* encode 4*4*4 floating-point block stored at p using strides (sx, sy, sz) */
-uint
-_t2(zfp_encode_block_strided, Scalar, 3)(zfp_stream* stream, const Scalar* p, int sx, int sy, int sz)
-{
-  /* gather block from strided array */
-  cache_align_(Scalar fblock[64]);
-  _t2(gather, Scalar, 3)(fblock, p, sx, sy, sz);
-  /* encode floating-point block */
-  return _t2(zfp_encode_block, Scalar, 3)(stream, fblock);
-}
-
-/* encode nx*ny*nz floating-point block stored at p using strides (sx, sy, sz) */
-uint
-_t2(zfp_encode_partial_block_strided, Scalar, 3)(zfp_stream* stream, const Scalar* p, uint nx, uint ny, uint nz, int sx, int sy, int sz)
-{
-  /* gather block from strided array */
-  cache_align_(Scalar fblock[64]);
-  _t2(gather_partial, Scalar, 3)(fblock, p, nx, ny, nz, sx, sy, sz);
-  /* encode floating-point block */
-  return _t2(zfp_encode_block, Scalar, 3)(stream, fblock);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/encode4.c b/ThirdParty/zfp/vtkzfp/src/template/encode4.c
deleted file mode 100644
index c9ed5425a3b1a8b3cdfd13676904983bebb55427..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/encode4.c
+++ /dev/null
@@ -1,89 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* gather 4*4*4*4 block from strided array */
-static void
-_t2(gather, Scalar, 4)(Scalar* q, const Scalar* p, int sx, int sy, int sz, int sw)
-{
-  uint x, y, z, w;
-  for (w = 0; w < 4; w++, p += sw - 4 * sz)
-    for (z = 0; z < 4; z++, p += sz - 4 * sy)
-      for (y = 0; y < 4; y++, p += sy - 4 * sx)
-        for (x = 0; x < 4; x++, p += sx)
-          *q++ = *p;
-}
-
-/* gather nx*ny*nz*nw block from strided array */
-static void
-_t2(gather_partial, Scalar, 4)(Scalar* q, const Scalar* p, uint nx, uint ny, uint nz, uint nw, int sx, int sy, int sz, int sw)
-{
-  uint x, y, z, w;
-  for (w = 0; w < nw; w++, p += sw - (ptrdiff_t)nz * sz) {
-    for (z = 0; z < nz; z++, p += sz - (ptrdiff_t)ny * sy) {
-      for (y = 0; y < ny; y++, p += sy - (ptrdiff_t)nx * sx) {
-        for (x = 0; x < nx; x++, p += sx)
-          q[64 * w + 16 * z + 4 * y + x] = *p; 
-        _t1(pad_block, Scalar)(q + 64 * w + 16 * z + 4 * y, nx, 1);
-      }
-      for (x = 0; x < 4; x++)
-        _t1(pad_block, Scalar)(q + 64 * w + 16 * z + x, ny, 4);
-    }
-    for (y = 0; y < 4; y++)
-      for (x = 0; x < 4; x++)
-        _t1(pad_block, Scalar)(q + 64 * w + 4 * y + x, nz, 16);
-  }
-  for (z = 0; z < 4; z++)
-    for (y = 0; y < 4; y++)
-      for (x = 0; x < 4; x++)
-        _t1(pad_block, Scalar)(q + 16 * z + 4 * y + x, nw, 64);
-}
-
-/* forward decorrelating 4D transform */
-static void
-_t2(fwd_xform, Int, 4)(Int* p)
-{
-  uint x, y, z, w;
-  /* transform along x */
-  for (w = 0; w < 4; w++)
-    for (z = 0; z < 4; z++)
-      for (y = 0; y < 4; y++)
-        _t1(fwd_lift, Int)(p + 4 * y + 16 * z + 64 * w, 1);
-  /* transform along y */
-  for (x = 0; x < 4; x++)
-    for (w = 0; w < 4; w++)
-      for (z = 0; z < 4; z++)
-        _t1(fwd_lift, Int)(p + 16 * z + 64 * w + 1 * x, 4);
-  /* transform along z */
-  for (y = 0; y < 4; y++)
-    for (x = 0; x < 4; x++)
-      for (w = 0; w < 4; w++)
-        _t1(fwd_lift, Int)(p + 64 * w + 1 * x + 4 * y, 16);
-  /* transform along w */
-  for (z = 0; z < 4; z++)
-    for (y = 0; y < 4; y++)
-      for (x = 0; x < 4; x++)
-        _t1(fwd_lift, Int)(p + 1 * x + 4 * y + 16 * z, 64);
-}
-
-/* public functions -------------------------------------------------------- */
-
-/* encode 4*4*4*4 floating-point block stored at p using strides (sx, sy, sz, sw) */
-uint
-_t2(zfp_encode_block_strided, Scalar, 4)(zfp_stream* stream, const Scalar* p, int sx, int sy, int sz, int sw)
-{
-  /* gather block from strided array */
-  cache_align_(Scalar fblock[256]);
-  _t2(gather, Scalar, 4)(fblock, p, sx, sy, sz, sw);
-  /* encode floating-point block */
-  return _t2(zfp_encode_block, Scalar, 4)(stream, fblock);
-}
-
-/* encode nx*ny*nz*nw floating-point block stored at p using strides (sx, sy, sz, sw) */
-uint
-_t2(zfp_encode_partial_block_strided, Scalar, 4)(zfp_stream* stream, const Scalar* p, uint nx, uint ny, uint nz, uint nw, int sx, int sy, int sz, int sw)
-{
-  /* gather block from strided array */
-  cache_align_(Scalar fblock[256]);
-  _t2(gather_partial, Scalar, 4)(fblock, p, nx, ny, nz, nw, sx, sy, sz, sw);
-  /* encode floating-point block */
-  return _t2(zfp_encode_block, Scalar, 4)(stream, fblock);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/encodef.c b/ThirdParty/zfp/vtkzfp/src/template/encodef.c
deleted file mode 100644
index 5c6ec537d9ca3429f05a9fe2bd42ee2bf7916484..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/encodef.c
+++ /dev/null
@@ -1,91 +0,0 @@
-#include <limits.h>
-#include <math.h>
-
-static uint _t2(rev_encode_block, Scalar, DIMS)(zfp_stream* zfp, const Scalar* fblock);
-
-/* private functions ------------------------------------------------------- */
-
-/* return normalized floating-point exponent for x >= 0 */
-static int
-_t1(exponent, Scalar)(Scalar x)
-{
-  if (x > 0) {
-    int e;
-    FREXP(x, &e);
-    /* clamp exponent in case x is denormal */
-    return MAX(e, 1 - EBIAS);
-  }
-  return -EBIAS;
-}
-
-/* compute maximum floating-point exponent in block of n values */
-static int
-_t1(exponent_block, Scalar)(const Scalar* p, uint n)
-{
-  Scalar max = 0;
-  do {
-    Scalar f = FABS(*p++);
-    if (max < f)
-      max = f;
-  } while (--n);
-  return _t1(exponent, Scalar)(max);
-}
-
-/* map floating-point number x to integer relative to exponent e */
-static Scalar
-_t1(quantize, Scalar)(Scalar x, int e)
-{
-  return LDEXP(x, (CHAR_BIT * (int)sizeof(Scalar) - 2) - e);
-}
-
-/* forward block-floating-point transform to signed integers */
-static void
-_t1(fwd_cast, Scalar)(Int* iblock, const Scalar* fblock, uint n, int emax)
-{
-  /* compute power-of-two scale factor s */
-  Scalar s = _t1(quantize, Scalar)(1, emax);
-  /* compute p-bit int y = s*x where x is floating and |y| <= 2^(p-2) - 1 */
-  do
-    *iblock++ = (Int)(s * *fblock++);
-  while (--n);
-}
-
-/* encode contiguous floating-point block using lossy algorithm */
-static uint
-_t2(encode_block, Scalar, DIMS)(zfp_stream* zfp, const Scalar* fblock)
-{
-  uint bits = 1;
-  /* compute maximum exponent */
-  int emax = _t1(exponent_block, Scalar)(fblock, BLOCK_SIZE);
-  int maxprec = precision(emax, zfp->maxprec, zfp->minexp, DIMS);
-  uint e = maxprec ? emax + EBIAS : 0;
-  /* encode block only if biased exponent is nonzero */
-  if (e) {
-    cache_align_(Int iblock[BLOCK_SIZE]);
-    /* encode common exponent; LSB indicates that exponent is nonzero */
-    bits += EBITS;
-    stream_write_bits(zfp->stream, 2 * e + 1, bits);
-    /* perform forward block-floating-point transform */
-    _t1(fwd_cast, Scalar)(iblock, fblock, BLOCK_SIZE, emax);
-    /* encode integer block */
-    bits += _t2(encode_block, Int, DIMS)(zfp->stream, zfp->minbits - bits, zfp->maxbits - bits, maxprec, iblock);
-  }
-  else {
-    /* write single zero-bit to indicate that all values are zero */
-    stream_write_bit(zfp->stream, 0);
-    if (zfp->minbits > bits) {
-      stream_pad(zfp->stream, zfp->minbits - bits);
-      bits = zfp->minbits;
-    }
-  }
-  return bits;
-}
-
-/* public functions -------------------------------------------------------- */
-
-/* encode contiguous floating-point block */
-uint
-_t2(zfp_encode_block, Scalar, DIMS)(zfp_stream* zfp, const Scalar* fblock)
-{
-  return REVERSIBLE(zfp) ? _t2(rev_encode_block, Scalar, DIMS)(zfp, fblock) : _t2(encode_block, Scalar, DIMS)(zfp, fblock);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/encodei.c b/ThirdParty/zfp/vtkzfp/src/template/encodei.c
deleted file mode 100644
index 41d5fbd654e503f83c05e2f6612eb04658ad5d56..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/encodei.c
+++ /dev/null
@@ -1,15 +0,0 @@
-static uint _t2(rev_encode_block, Int, DIMS)(bitstream* stream, int minbits, int maxbits, int maxprec, Int* iblock);
-
-/* public functions -------------------------------------------------------- */
-
-/* encode contiguous integer block */
-uint
-_t2(zfp_encode_block, Int, DIMS)(zfp_stream* zfp, const Int* iblock)
-{
-  cache_align_(Int block[BLOCK_SIZE]);
-  uint i;
-  /* copy block */
-  for (i = 0; i < BLOCK_SIZE; i++)
-    block[i] = iblock[i];
-  return REVERSIBLE(zfp) ? _t2(rev_encode_block, Int, DIMS)(zfp->stream, zfp->minbits, zfp->maxbits, zfp->maxprec, block) : _t2(encode_block, Int, DIMS)(zfp->stream, zfp->minbits, zfp->maxbits, zfp->maxprec, block);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/ompcompress.c b/ThirdParty/zfp/vtkzfp/src/template/ompcompress.c
deleted file mode 100644
index b0f86d230458a3aed2415358617551808cb538e5..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/ompcompress.c
+++ /dev/null
@@ -1,275 +0,0 @@
-#ifdef _OPENMP
-
-/* compress 1d contiguous array in parallel */
-static void
-_t2(compress_omp, Scalar, 1)(zfp_stream* stream, const zfp_field* field)
-{
-  /* array metadata */
-  const Scalar* data = (const Scalar*)field->data;
-  uint nx = field->nx;
-
-  /* number of omp threads, blocks, and chunks */
-  uint threads = thread_count_omp(stream);
-  uint blocks = (nx + 3) / 4;
-  uint chunks = chunk_count_omp(stream, blocks, threads);
-
-  /* allocate per-thread streams */
-  bitstream** bs = compress_init_par(stream, field, chunks, blocks);
-  if (!bs)
-    return;
-
-  /* compress chunks of blocks in parallel */
-  int chunk;
-  #pragma omp parallel for num_threads(threads)
-  for (chunk = 0; chunk < (int)chunks; chunk++) {
-    /* determine range of block indices assigned to this thread */
-    uint bmin = chunk_offset(blocks, chunks, chunk + 0);
-    uint bmax = chunk_offset(blocks, chunks, chunk + 1);
-    uint block;
-    /* set up thread-local bit stream */
-    zfp_stream s = *stream;
-    zfp_stream_set_bit_stream(&s, bs[chunk]);
-    /* compress sequence of blocks */
-    for (block = bmin; block < bmax; block++) {
-      /* determine block origin x within array */
-      const Scalar* p = data;
-      uint x = 4 * block;
-      p += x;
-      /* compress partial or full block */
-      if (nx - x < 4)
-        _t2(zfp_encode_partial_block_strided, Scalar, 1)(&s, p, MIN(nx - x, 4u), 1);
-      else
-        _t2(zfp_encode_block, Scalar, 1)(&s, p);
-    }
-  }
-
-  /* concatenate per-thread streams */
-  compress_finish_par(stream, bs, chunks);
-}
-
-/* compress 1d strided array in parallel */
-static void
-_t2(compress_strided_omp, Scalar, 1)(zfp_stream* stream, const zfp_field* field)
-{
-  /* array metadata */
-  const Scalar* data = (const Scalar*)field->data;
-  uint nx = field->nx;
-  int sx = field->sx ? field->sx : 1;
-
-  /* number of omp threads, blocks, and chunks */
-  uint threads = thread_count_omp(stream);
-  uint blocks = (nx + 3) / 4;
-  uint chunks = chunk_count_omp(stream, blocks, threads);
-
-  /* allocate per-thread streams */
-  bitstream** bs = compress_init_par(stream, field, chunks, blocks);
-  if (!bs)
-    return;
-
-  /* compress chunks of blocks in parallel */
-  int chunk;
-  #pragma omp parallel for num_threads(threads)
-  for (chunk = 0; chunk < (int)chunks; chunk++) {
-    /* determine range of block indices assigned to this thread */
-    uint bmin = chunk_offset(blocks, chunks, chunk + 0);
-    uint bmax = chunk_offset(blocks, chunks, chunk + 1);
-    uint block;
-    /* set up thread-local bit stream */
-    zfp_stream s = *stream;
-    zfp_stream_set_bit_stream(&s, bs[chunk]);
-    /* compress sequence of blocks */
-    for (block = bmin; block < bmax; block++) {
-      /* determine block origin x within array */
-      const Scalar* p = data;
-      uint x = 4 * block;
-      p += sx * (ptrdiff_t)x;
-      /* compress partial or full block */
-      if (nx - x < 4)
-        _t2(zfp_encode_partial_block_strided, Scalar, 1)(&s, p, MIN(nx - x, 4u), sx);
-      else
-        _t2(zfp_encode_block_strided, Scalar, 1)(&s, p, sx);
-    }
-  }
-
-  /* concatenate per-thread streams */
-  compress_finish_par(stream, bs, chunks);
-}
-
-/* compress 2d strided array in parallel */
-static void
-_t2(compress_strided_omp, Scalar, 2)(zfp_stream* stream, const zfp_field* field)
-{
-  /* array metadata */
-  const Scalar* data = (const Scalar*)field->data;
-  uint nx = field->nx;
-  uint ny = field->ny;
-  int sx = field->sx ? field->sx : 1;
-  int sy = field->sy ? field->sy : (int)nx;
-
-  /* number of omp threads, blocks, and chunks */
-  uint threads = thread_count_omp(stream);
-  uint bx = (nx + 3) / 4;
-  uint by = (ny + 3) / 4;
-  uint blocks = bx * by;
-  uint chunks = chunk_count_omp(stream, blocks, threads);
-
-  /* allocate per-thread streams */
-  bitstream** bs = compress_init_par(stream, field, chunks, blocks);
-  if (!bs)
-    return;
-
-  /* compress chunks of blocks in parallel */
-  int chunk;
-  #pragma omp parallel for num_threads(threads)
-  for (chunk = 0; chunk < (int)chunks; chunk++) {
-    /* determine range of block indices assigned to this thread */
-    uint bmin = chunk_offset(blocks, chunks, chunk + 0);
-    uint bmax = chunk_offset(blocks, chunks, chunk + 1);
-    uint block;
-    /* set up thread-local bit stream */
-    zfp_stream s = *stream;
-    zfp_stream_set_bit_stream(&s, bs[chunk]);
-    /* compress sequence of blocks */
-    for (block = bmin; block < bmax; block++) {
-      /* determine block origin (x, y) within array */
-      const Scalar* p = data;
-      uint b = block;
-      uint x, y;
-      x = 4 * (b % bx); b /= bx;
-      y = 4 * b;
-      p += sx * (ptrdiff_t)x + sy * (ptrdiff_t)y;
-      /* compress partial or full block */
-      if (nx - x < 4 || ny - y < 4)
-        _t2(zfp_encode_partial_block_strided, Scalar, 2)(&s, p, MIN(nx - x, 4u), MIN(ny - y, 4u), sx, sy);
-      else
-        _t2(zfp_encode_block_strided, Scalar, 2)(&s, p, sx, sy);
-    }
-  }
-
-  /* concatenate per-thread streams */
-  compress_finish_par(stream, bs, chunks);
-}
-
-/* compress 3d strided array in parallel */
-static void
-_t2(compress_strided_omp, Scalar, 3)(zfp_stream* stream, const zfp_field* field)
-{
-  /* array metadata */
-  const Scalar* data = (const Scalar*)field->data;
-  uint nx = field->nx;
-  uint ny = field->ny;
-  uint nz = field->nz;
-  int sx = field->sx ? field->sx : 1;
-  int sy = field->sy ? field->sy : (int)nx;
-  int sz = field->sz ? field->sz : (int)(nx * ny);
-
-  /* number of omp threads, blocks, and chunks */
-  uint threads = thread_count_omp(stream);
-  uint bx = (nx + 3) / 4;
-  uint by = (ny + 3) / 4;
-  uint bz = (nz + 3) / 4;
-  uint blocks = bx * by * bz;
-  uint chunks = chunk_count_omp(stream, blocks, threads);
-
-  /* allocate per-thread streams */
-  bitstream** bs = compress_init_par(stream, field, chunks, blocks);
-  if (!bs)
-    return;
-
-  /* compress chunks of blocks in parallel */
-  int chunk;
-  #pragma omp parallel for num_threads(threads)
-  for (chunk = 0; chunk < (int)chunks; chunk++) {
-    /* determine range of block indices assigned to this thread */
-    uint bmin = chunk_offset(blocks, chunks, chunk + 0);
-    uint bmax = chunk_offset(blocks, chunks, chunk + 1);
-    uint block;
-    /* set up thread-local bit stream */
-    zfp_stream s = *stream;
-    zfp_stream_set_bit_stream(&s, bs[chunk]);
-    /* compress sequence of blocks */
-    for (block = bmin; block < bmax; block++) {
-      /* determine block origin (x, y, z) within array */
-      const Scalar* p = data;
-      uint b = block;
-      uint x, y, z;
-      x = 4 * (b % bx); b /= bx;
-      y = 4 * (b % by); b /= by;
-      z = 4 * b;
-      p += sx * (ptrdiff_t)x + sy * (ptrdiff_t)y + sz * (ptrdiff_t)z;
-      /* compress partial or full block */
-      if (nx - x < 4 || ny - y < 4 || nz - z < 4)
-        _t2(zfp_encode_partial_block_strided, Scalar, 3)(&s, p, MIN(nx - x, 4u), MIN(ny - y, 4u), MIN(nz - z, 4u), sx, sy, sz);
-      else
-        _t2(zfp_encode_block_strided, Scalar, 3)(&s, p, sx, sy, sz);
-    }
-  }
-
-  /* concatenate per-thread streams */
-  compress_finish_par(stream, bs, chunks);
-}
-
-/* compress 4d strided array in parallel */
-static void
-_t2(compress_strided_omp, Scalar, 4)(zfp_stream* stream, const zfp_field* field)
-{
-  /* array metadata */
-  const Scalar* data = field->data;
-  uint nx = field->nx;
-  uint ny = field->ny;
-  uint nz = field->nz;
-  uint nw = field->nw;
-  int sx = field->sx ? field->sx : 1;
-  int sy = field->sy ? field->sy : (int)nx;
-  int sz = field->sz ? field->sz : (int)(nx * ny);
-  int sw = field->sw ? field->sw : (int)(nx * ny * nz);
-
-  /* number of omp threads, blocks, and chunks */
-  uint threads = thread_count_omp(stream);
-  uint bx = (nx + 3) / 4;
-  uint by = (ny + 3) / 4;
-  uint bz = (nz + 3) / 4;
-  uint bw = (nw + 3) / 4;
-  uint blocks = bx * by * bz * bw;
-  uint chunks = chunk_count_omp(stream, blocks, threads);
-
-  /* allocate per-thread streams */
-  bitstream** bs = compress_init_par(stream, field, chunks, blocks);
-  if (!bs)
-    return;
-
-  /* compress chunks of blocks in parallel */
-  int chunk;
-  #pragma omp parallel for num_threads(threads)
-  for (chunk = 0; chunk < (int)chunks; chunk++) {
-    /* determine range of block indices assigned to this thread */
-    uint bmin = chunk_offset(blocks, chunks, chunk + 0);
-    uint bmax = chunk_offset(blocks, chunks, chunk + 1);
-    uint block;
-    /* set up thread-local bit stream */
-    zfp_stream s = *stream;
-    zfp_stream_set_bit_stream(&s, bs[chunk]);
-    /* compress sequence of blocks */
-    for (block = bmin; block < bmax; block++) {
-      /* determine block origin (x, y, z, w) within array */
-      const Scalar* p = data;
-      uint b = block;
-      uint x, y, z, w;
-      x = 4 * (b % bx); b /= bx;
-      y = 4 * (b % by); b /= by;
-      z = 4 * (b % bz); b /= bz;
-      w = 4 * b;
-      p += sx * (ptrdiff_t)x + sy * (ptrdiff_t)y + sz * (ptrdiff_t)z + sw * (ptrdiff_t)w;
-      /* compress partial or full block */
-      if (nx - x < 4 || ny - y < 4 || nz - z < 4 || nw - w < 4)
-        _t2(zfp_encode_partial_block_strided, Scalar, 4)(&s, p, MIN(nx - x, 4u), MIN(ny - y, 4u), MIN(nz - z, 4u), MIN(nw - w, 4u), sx, sy, sz, sw);
-      else
-        _t2(zfp_encode_block_strided, Scalar, 4)(&s, p, sx, sy, sz, sw);
-    }
-  }
-
-  /* concatenate per-thread streams */
-  compress_finish_par(stream, bs, chunks);
-}
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/src/template/revcodecf.c b/ThirdParty/zfp/vtkzfp/src/template/revcodecf.c
deleted file mode 100644
index ad5f788643ec0247955ddb0f7903908fd0eb0586..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/revcodecf.c
+++ /dev/null
@@ -1,11 +0,0 @@
-/* inverse block-floating-point transform from signed integers */
-static void
-_t1(rev_inv_cast, Scalar)(const Int* iblock, Scalar* fblock, uint n, int emax)
-{
-  /* test for all-zero block, which needs special treatment */
-  if (emax != -EBIAS)
-    _t1(inv_cast, Scalar)(iblock, fblock, n, emax);
-  else
-    while (n--)
-      *fblock++ = 0;
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/revdecode.c b/ThirdParty/zfp/vtkzfp/src/template/revdecode.c
deleted file mode 100644
index cde9877f6473a7ac6a6dad263e09692f8979c3fc..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/revdecode.c
+++ /dev/null
@@ -1,55 +0,0 @@
-static void _t2(rev_inv_xform, Int, DIMS)(Int* p);
-
-/* private functions ------------------------------------------------------- */
-
-/* reversible inverse lifting transform of 4-vector */
-static void
-_t1(rev_inv_lift, Int)(Int* p, uint s)
-{
-  Int x, y, z, w;
-  x = *p; p += s;
-  y = *p; p += s;
-  z = *p; p += s;
-  w = *p; p += s;
-
-  /*
-  ** high-order Lorenzo transform (P4 Pascal matrix)
-  ** ( 1  0  0  0) (x)
-  ** ( 1  1  0  0) (y)
-  ** ( 1  2  1  0) (z)
-  ** ( 1  3  3  1) (w)
-  */
-  w += z;
-  z += y; w += z;
-  y += x; z += y; w += z;
-
-  p -= s; *p = w;
-  p -= s; *p = z;
-  p -= s; *p = y;
-  p -= s; *p = x;
-}
-
-/* decode block of integers using reversible algorithm */
-static uint
-_t2(rev_decode_block, Int, DIMS)(bitstream* stream, int minbits, int maxbits, Int* iblock)
-{
-  /* decode number of significant bits */
-  int bits = PBITS;
-  int prec = (int)stream_read_bits(stream, PBITS) + 1;
-  cache_align_(UInt ublock[BLOCK_SIZE]);
-  /* decode integer coefficients */
-  if (BLOCK_SIZE <= 64)
-    bits += _t1(decode_ints, UInt)(stream, maxbits - bits, prec, ublock, BLOCK_SIZE);
-  else
-    bits += _t1(decode_many_ints, UInt)(stream, maxbits - bits, prec, ublock, BLOCK_SIZE);
-  /* read at least minbits bits */
-  if (bits < minbits) {
-    stream_skip(stream, minbits - bits);
-    bits = minbits;
-  }
-  /* reorder unsigned coefficients and convert to signed integer */
-  _t1(inv_order, Int)(ublock, iblock, PERM, BLOCK_SIZE);
-  /* perform decorrelating transform */
-  _t2(rev_inv_xform, Int, DIMS)(iblock);
-  return bits;
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/revdecode1.c b/ThirdParty/zfp/vtkzfp/src/template/revdecode1.c
deleted file mode 100644
index 018a10151ce78911f88c4b493cc871188d9da48d..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/revdecode1.c
+++ /dev/null
@@ -1,9 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* reversible inverse decorrelating 1D transform */
-static void
-_t2(rev_inv_xform, Int, 1)(Int* p)
-{
-  /* transform along x */
-  _t1(rev_inv_lift, Int)(p, 1);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/revdecode2.c b/ThirdParty/zfp/vtkzfp/src/template/revdecode2.c
deleted file mode 100644
index 9cb8669c7d24ace72f04dcad96b6e9aefed81a3d..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/revdecode2.c
+++ /dev/null
@@ -1,14 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* reversible inverse decorrelating 2D transform */
-static void
-_t2(rev_inv_xform, Int, 2)(Int* p)
-{
-  uint x, y;
-  /* transform along y */
-  for (x = 0; x < 4; x++)
-    _t1(rev_inv_lift, Int)(p + 1 * x, 4);
-  /* transform along x */
-  for (y = 0; y < 4; y++)
-    _t1(rev_inv_lift, Int)(p + 4 * y, 1);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/revdecode3.c b/ThirdParty/zfp/vtkzfp/src/template/revdecode3.c
deleted file mode 100644
index 12194437142ce2cfcaa153374a53a072f5c958f7..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/revdecode3.c
+++ /dev/null
@@ -1,20 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* reversible inverse decorrelating 3D transform */
-static void
-_t2(rev_inv_xform, Int, 3)(Int* p)
-{
-  uint x, y, z;
-  /* transform along z */
-  for (y = 0; y < 4; y++)
-    for (x = 0; x < 4; x++)
-      _t1(rev_inv_lift, Int)(p + 1 * x + 4 * y, 16);
-  /* transform along y */
-  for (x = 0; x < 4; x++)
-    for (z = 0; z < 4; z++)
-      _t1(rev_inv_lift, Int)(p + 16 * z + 1 * x, 4);
-  /* transform along x */
-  for (z = 0; z < 4; z++)
-    for (y = 0; y < 4; y++)
-      _t1(rev_inv_lift, Int)(p + 4 * y + 16 * z, 1);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/revdecode4.c b/ThirdParty/zfp/vtkzfp/src/template/revdecode4.c
deleted file mode 100644
index 98a98f80b7f5604c4812d1f7698cb2243de1867f..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/revdecode4.c
+++ /dev/null
@@ -1,28 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* reversible inverse decorrelating 4D transform */
-static void
-_t2(rev_inv_xform, Int, 4)(Int* p)
-{
-  uint x, y, z, w;
-  /* transform along w */
-  for (z = 0; z < 4; z++)
-    for (y = 0; y < 4; y++)
-      for (x = 0; x < 4; x++)
-        _t1(rev_inv_lift, Int)(p + 1 * x + 4 * y + 16 * z, 64);
-  /* transform along z */
-  for (y = 0; y < 4; y++)
-    for (x = 0; x < 4; x++)
-      for (w = 0; w < 4; w++)
-        _t1(rev_inv_lift, Int)(p + 64 * w + 1 * x + 4 * y, 16);
-  /* transform along y */
-  for (x = 0; x < 4; x++)
-    for (w = 0; w < 4; w++)
-      for (z = 0; z < 4; z++)
-        _t1(rev_inv_lift, Int)(p + 16 * z + 64 * w + 1 * x, 4);
-  /* transform along x */
-  for (w = 0; w < 4; w++)
-    for (z = 0; z < 4; z++)
-      for (y = 0; y < 4; y++)
-        _t1(rev_inv_lift, Int)(p + 4 * y + 16 * z + 64 * w, 1);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/revdecodef.c b/ThirdParty/zfp/vtkzfp/src/template/revdecodef.c
deleted file mode 100644
index 221a4b2e513830fffdcc27584b1c9cb6c4ce5fe5..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/revdecodef.c
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <string.h>
-
-/* private functions ------------------------------------------------------- */
-
-/* reinterpret two's complement integers as floating values */
-static void
-_t1(rev_inv_reinterpret, Scalar)(Int* iblock, Scalar* fblock, uint n)
-{
-  /* convert two's complement integers to sign-magnitude integers */
-  uint i;
-  for (i = 0; i < n; i++) {
-    Int x = iblock[i];
-    if (x < 0)
-      iblock[i] = (Int)((UInt)x ^ TCMASK);
-  }
-  /* reinterpret sign-magnitude integers as floating values */
-  memcpy(fblock, iblock, n * sizeof(*fblock));
-}
-
-/* decode contiguous floating-point block using reversible algorithm */
-static uint
-_t2(rev_decode_block, Scalar, DIMS)(zfp_stream* zfp, Scalar* fblock)
-{
-  uint bits = 0;
-  cache_align_(Int iblock[BLOCK_SIZE]);
-  /* test whether block is all-zero */
-  bits++;
-  if (stream_read_bit(zfp->stream)) {
-    /* non-zero block; test whether to use block-floating-point transform */
-    bits++;
-    if (stream_read_bit(zfp->stream)) {
-      /* decode integer block */
-      bits += _t2(rev_decode_block, Int, DIMS)(zfp->stream, zfp->minbits - bits, zfp->maxbits - bits, iblock);
-      /* reinterpret integers as floating values */
-      _t1(rev_inv_reinterpret, Scalar)(iblock, fblock, BLOCK_SIZE);
-    }
-    else {
-      /* decode common exponent */
-      bits += EBITS;
-      int emax = (int)stream_read_bits(zfp->stream, EBITS) - EBIAS;
-      /* decode integer block */
-      bits += _t2(rev_decode_block, Int, DIMS)(zfp->stream, zfp->minbits - bits, zfp->maxbits - bits, iblock);
-      /* perform inverse block-floating-point transform */
-      _t1(rev_inv_cast, Scalar)(iblock, fblock, BLOCK_SIZE, emax);
-    }
-  }
-  else {
-    /* all-zero block; set all values to zero */
-    uint i;
-    for (i = 0; i < BLOCK_SIZE; i++)
-      *fblock++ = 0;
-    if (zfp->minbits > bits) {
-      stream_skip(zfp->stream, zfp->minbits - bits);
-      bits = zfp->minbits;
-    }
-  }
-  return bits;
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/revencode.c b/ThirdParty/zfp/vtkzfp/src/template/revencode.c
deleted file mode 100644
index f76238e986dc4118db9e6f327c015406efe3a104..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/revencode.c
+++ /dev/null
@@ -1,79 +0,0 @@
-static void _t2(rev_fwd_xform, Int, DIMS)(Int* p);
-
-/* private functions ------------------------------------------------------- */
-
-/* reversible forward lifting transform of 4-vector */
-static void
-_t1(rev_fwd_lift, Int)(Int* p, uint s)
-{
-  Int x, y, z, w;
-  x = *p; p += s;
-  y = *p; p += s;
-  z = *p; p += s;
-  w = *p; p += s;
-
-  /*
-  ** high-order Lorenzo transform
-  ** ( 1  0  0  0) (x)
-  ** (-1  1  0  0) (y)
-  ** ( 1 -2  1  0) (z)
-  ** (-1  3 -3  1) (w)
-  */
-  w -= z; z -= y; y -= x;
-  w -= z; z -= y;
-  w -= z;
-
-  p -= s; *p = w;
-  p -= s; *p = z;
-  p -= s; *p = y;
-  p -= s; *p = x;
-}
-
-/* return precision required to encode block reversibly */
-static uint
-_t1(rev_precision, UInt)(const UInt* block, uint n)
-{
-  uint p = 0;
-  uint s;
-  /* compute bitwise OR of all values */
-  UInt m = 0;
-  while (n--)
-    m |= *block++;
-  /* count trailing zeros via binary search */
-  for (s = CHAR_BIT * (uint)sizeof(UInt); m; s /= 2)
-    if ((UInt)(m << (s - 1))) {
-      m <<= s - 1;
-      m <<= 1;
-      p += s;
-    }
-  return p;
-}
-
-/* encode block of integers using reversible algorithm */
-static uint
-_t2(rev_encode_block, Int, DIMS)(bitstream* stream, int minbits, int maxbits, int maxprec, Int* iblock)
-{
-  int bits = PBITS;
-  int prec;
-  cache_align_(UInt ublock[BLOCK_SIZE]);
-  /* perform decorrelating transform */
-  _t2(rev_fwd_xform, Int, DIMS)(iblock);
-  /* reorder signed coefficients and convert to unsigned integer */
-  _t1(fwd_order, Int)(ublock, iblock, PERM, BLOCK_SIZE);
-  /* determine and encode number of significant bits */
-  prec = _t1(rev_precision, UInt)(ublock, BLOCK_SIZE);
-  prec = MIN(prec, maxprec);
-  prec = MAX(prec, 1);
-  stream_write_bits(stream, prec - 1, PBITS);
-  /* encode integer coefficients */
-  if (BLOCK_SIZE <= 64)
-    bits += _t1(encode_ints, UInt)(stream, maxbits - bits, prec, ublock, BLOCK_SIZE);
-  else
-    bits += _t1(encode_many_ints, UInt)(stream, maxbits - bits, prec, ublock, BLOCK_SIZE);
-  /* write at least minbits bits by padding with zeros */
-  if (bits < minbits) {
-    stream_pad(stream, minbits - bits);
-    bits = minbits;
-  }
-  return bits;
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/revencode1.c b/ThirdParty/zfp/vtkzfp/src/template/revencode1.c
deleted file mode 100644
index 1e7b29a41a8b0a8b630208656a2660dcd6f40639..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/revencode1.c
+++ /dev/null
@@ -1,9 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* reversible forward decorrelating 1D transform */
-static void
-_t2(rev_fwd_xform, Int, 1)(Int* p)
-{
-  /* transform along x */
-  _t1(rev_fwd_lift, Int)(p, 1);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/revencode2.c b/ThirdParty/zfp/vtkzfp/src/template/revencode2.c
deleted file mode 100644
index 621fc0cc60ac8231081f01aeba861eb0ef47482a..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/revencode2.c
+++ /dev/null
@@ -1,14 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* reversible forward decorrelating 2D transform */
-static void
-_t2(rev_fwd_xform, Int, 2)(Int* p)
-{
-  uint x, y;
-  /* transform along x */
-  for (y = 0; y < 4; y++)
-    _t1(rev_fwd_lift, Int)(p + 4 * y, 1);
-  /* transform along y */
-  for (x = 0; x < 4; x++)
-    _t1(rev_fwd_lift, Int)(p + 1 * x, 4);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/revencode3.c b/ThirdParty/zfp/vtkzfp/src/template/revencode3.c
deleted file mode 100644
index 64d49f19d6873c568a58b7936105c01d20147cff..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/revencode3.c
+++ /dev/null
@@ -1,20 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* reversible forward decorrelating 3D transform */
-static void
-_t2(rev_fwd_xform, Int, 3)(Int* p)
-{
-  uint x, y, z;
-  /* transform along x */
-  for (z = 0; z < 4; z++)
-    for (y = 0; y < 4; y++)
-      _t1(rev_fwd_lift, Int)(p + 4 * y + 16 * z, 1);
-  /* transform along y */
-  for (x = 0; x < 4; x++)
-    for (z = 0; z < 4; z++)
-      _t1(rev_fwd_lift, Int)(p + 16 * z + 1 * x, 4);
-  /* transform along z */
-  for (y = 0; y < 4; y++)
-    for (x = 0; x < 4; x++)
-      _t1(rev_fwd_lift, Int)(p + 1 * x + 4 * y, 16);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/revencode4.c b/ThirdParty/zfp/vtkzfp/src/template/revencode4.c
deleted file mode 100644
index 46e2a465c4f9990c2457b371ebda58d19e9c93dd..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/revencode4.c
+++ /dev/null
@@ -1,28 +0,0 @@
-/* private functions ------------------------------------------------------- */
-
-/* reversible forward decorrelating 4D transform */
-static void
-_t2(rev_fwd_xform, Int, 4)(Int* p)
-{
-  uint x, y, z, w;
-  /* transform along x */
-  for (w = 0; w < 4; w++)
-    for (z = 0; z < 4; z++)
-      for (y = 0; y < 4; y++)
-        _t1(rev_fwd_lift, Int)(p + 4 * y + 16 * z + 64 * w, 1);
-  /* transform along y */
-  for (x = 0; x < 4; x++)
-    for (w = 0; w < 4; w++)
-      for (z = 0; z < 4; z++)
-        _t1(rev_fwd_lift, Int)(p + 16 * z + 64 * w + 1 * x, 4);
-  /* transform along z */
-  for (y = 0; y < 4; y++)
-    for (x = 0; x < 4; x++)
-      for (w = 0; w < 4; w++)
-        _t1(rev_fwd_lift, Int)(p + 64 * w + 1 * x + 4 * y, 16);
-  /* transform along w */
-  for (z = 0; z < 4; z++)
-    for (y = 0; y < 4; y++)
-      for (x = 0; x < 4; x++)
-        _t1(rev_fwd_lift, Int)(p + 1 * x + 4 * y + 16 * z, 64);
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/revencodef.c b/ThirdParty/zfp/vtkzfp/src/template/revencodef.c
deleted file mode 100644
index 44ef3749072197cf6aa503ef137f87f06db1d935..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/revencodef.c
+++ /dev/null
@@ -1,80 +0,0 @@
-#include <string.h>
-
-/* private functions ------------------------------------------------------- */
-
-/* test if block-floating-point encoding is reversible */
-static int
-_t1(rev_fwd_reversible, Scalar)(const Int* iblock, const Scalar* fblock, uint n, int emax)
-{
-  /* reconstruct block */
-  cache_align_(Scalar gblock[BLOCK_SIZE]);
-  _t1(rev_inv_cast, Scalar)(iblock, gblock, n, emax);
-  /* perform bit-wise comparison */
-  return !memcmp(fblock, gblock, n * sizeof(*fblock));
-}
-
-/* forward block-floating-point transform to signed integers */
-static void
-_t1(rev_fwd_cast, Scalar)(Int* iblock, const Scalar* fblock, uint n, int emax)
-{
-  /* test for all-zero block, which needs special treatment */
-  if (emax != -EBIAS)
-    _t1(fwd_cast, Scalar)(iblock, fblock, BLOCK_SIZE, emax);
-  else
-    while (n--)
-      *iblock++ = 0;
-}
-
-/* reinterpret floating values as two's complement integers */
-static void
-_t1(rev_fwd_reinterpret, Scalar)(Int* iblock, const Scalar* fblock, uint n)
-{
-  /* reinterpret floating values as sign-magnitude integers */
-  memcpy(iblock, fblock, n * sizeof(*iblock));
-  /* convert sign-magnitude integers to two's complement integers */
-  while (n--) {
-    Int x = *iblock;
-    if (x < 0)
-      *iblock = (Int)((UInt)x ^ TCMASK);
-    iblock++;
-  }
-}
-
-/* encode contiguous floating-point block using reversible algorithm */
-static uint
-_t2(rev_encode_block, Scalar, DIMS)(zfp_stream* zfp, const Scalar* fblock)
-{
-  uint bits = 0;
-  cache_align_(Int iblock[BLOCK_SIZE]);
-  /* compute maximum exponent */
-  int emax = _t1(exponent_block, Scalar)(fblock, BLOCK_SIZE);
-  /* perform forward block-floating-point transform */
-  _t1(rev_fwd_cast, Scalar)(iblock, fblock, BLOCK_SIZE, emax);
-  /* test if block-floating-point transform is reversible */
-  if (_t1(rev_fwd_reversible, Scalar)(iblock, fblock, BLOCK_SIZE, emax)) {
-    /* transform is reversible; test if block has any non-zeros */
-    uint e = emax + EBIAS;
-    if (e) {
-      /* encode common exponent */
-      bits += 2;
-      stream_write_bits(zfp->stream, 1, 2);
-      bits += EBITS;
-      stream_write_bits(zfp->stream, e, EBITS);
-    }
-    else {
-      /* emit single bit for all-zero block */
-      bits++;
-      stream_write_bit(zfp->stream, 0);
-      return bits;
-    }
-  }
-  else {
-    /* transform is irreversible; reinterpret floating values as integers */
-    _t1(rev_fwd_reinterpret, Scalar)(iblock, fblock, BLOCK_SIZE);
-    bits++;
-    stream_write_bits(zfp->stream, 3, 2);
-  }
-  /* losslessly encode integers */
-  bits += _t2(rev_encode_block, Int, DIMS)(zfp->stream, zfp->minbits - bits, zfp->maxbits - bits, zfp->maxprec, iblock);
-  return bits;
-}
diff --git a/ThirdParty/zfp/vtkzfp/src/template/template.h b/ThirdParty/zfp/vtkzfp/src/template/template.h
deleted file mode 100644
index fd5becf7e4c25c9bfb326deb68c490b57ddcef41..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/template/template.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef TEMPLATE_H
-#define TEMPLATE_H
-
-/* concatenation */
-#define _cat2(x, y)    x ## _ ## y
-#define _cat3(x, y, z) x ## _ ## y ## _ ## z
-
-/* 1- and 2-argument function templates */
-#define _t1(function, arg)        _cat2(function, arg)
-#define _t2(function, type, dims) _cat3(function, type, dims)
-
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/src/traitsd.h b/ThirdParty/zfp/vtkzfp/src/traitsd.h
deleted file mode 100644
index 4dfb271b83be5ba497f94b3b7e022d1b8aba9948..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/traitsd.h
+++ /dev/null
@@ -1,13 +0,0 @@
-/* double-precision floating-point traits */
-
-#define Scalar double                      /* floating-point type */
-#define Int int64                          /* corresponding signed integer type */
-#define UInt uint64                        /* corresponding unsigned integer type */
-#define EBITS 11                           /* number of exponent bits */
-#define PBITS 6                            /* number of bits needed to encode precision */
-#define NBMASK UINT64C(0xaaaaaaaaaaaaaaaa) /* negabinary mask */
-#define TCMASK UINT64C(0x7fffffffffffffff) /* two's complement mask */
-
-#define FABS(x) fabs(x)
-#define FREXP(x, e) frexp(x, e)
-#define LDEXP(x, e) ldexp(x, e)
diff --git a/ThirdParty/zfp/vtkzfp/src/traitsf.h b/ThirdParty/zfp/vtkzfp/src/traitsf.h
deleted file mode 100644
index 408337e1e1e5b1491e750c190cf9a6e3c5ba56e3..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/traitsf.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/* single-precision floating-point traits */
-
-#define Scalar float       /* floating-point type */
-#define Int int32          /* corresponding signed integer type */
-#define UInt uint32        /* corresponding unsigned integer type */
-#define EBITS 8            /* number of exponent bits */
-#define PBITS 5            /* number of bits needed to encode precision */
-#define NBMASK 0xaaaaaaaau /* negabinary mask */
-#define TCMASK 0x7fffffffu /* two's complement mask */
-
-#if __STDC_VERSION__ >= 199901L
-  #define FABS(x)     fabsf(x)
-  #define FREXP(x, e) frexpf(x, e)
-  #define LDEXP(x, e) ldexpf(x, e)
-#else
-  #define FABS(x)     (float)fabs(x)
-  #define FREXP(x, e) (void)frexp(x, e)
-  #define LDEXP(x, e) (float)ldexp(x, e)
-#endif
diff --git a/ThirdParty/zfp/vtkzfp/src/traitsi.h b/ThirdParty/zfp/vtkzfp/src/traitsi.h
deleted file mode 100644
index a540fb4017bb1d57bf24aa9d5dde6cf68f3b39d4..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/traitsi.h
+++ /dev/null
@@ -1,7 +0,0 @@
-/* 32-bit integer traits */
-
-#define Scalar int32       /* integer type */
-#define Int int32          /* corresponding signed integer type */
-#define UInt uint32        /* corresponding unsigned integer type */
-#define PBITS 5            /* number of bits needed to encode precision */
-#define NBMASK 0xaaaaaaaau /* negabinary mask */
diff --git a/ThirdParty/zfp/vtkzfp/src/traitsl.h b/ThirdParty/zfp/vtkzfp/src/traitsl.h
deleted file mode 100644
index ffa01e0b703fc4b17b18eaca1d64e21268e39efa..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/traitsl.h
+++ /dev/null
@@ -1,7 +0,0 @@
-/* 64-bit integer traits */
-
-#define Scalar int64                       /* integer type */
-#define Int int64                          /* corresponding signed integer type */
-#define UInt uint64                        /* corresponding unsigned integer type */
-#define PBITS 6                            /* number of bits needed to encode precision */
-#define NBMASK UINT64C(0xaaaaaaaaaaaaaaaa) /* negabinary mask */
diff --git a/ThirdParty/zfp/vtkzfp/src/zfp.c b/ThirdParty/zfp/vtkzfp/src/zfp.c
deleted file mode 100644
index 54a0e5f2ac0bc6c299ec25b32c0d0f803a70678f..0000000000000000000000000000000000000000
--- a/ThirdParty/zfp/vtkzfp/src/zfp.c
+++ /dev/null
@@ -1,1092 +0,0 @@
-#include <limits.h>
-#include <math.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include "zfp.h"
-#include "zfp/macros.h"
-#include "template/template.h"
-
-/* public data ------------------------------------------------------------- */
-
-export_ const uint zfp_codec_version = ZFP_CODEC;
-export_ const uint zfp_library_version = ZFP_VERSION;
-export_ const char* const zfp_version_string = "zfp version " ZFP_VERSION_STRING " (May 5, 2019)";
-
-/* private functions ------------------------------------------------------- */
-
-static uint
-type_precision(zfp_type type)
-{
-  switch (type) {
-    case zfp_type_int32:
-      return CHAR_BIT * (uint)sizeof(int32);
-    case zfp_type_int64:
-      return CHAR_BIT * (uint)sizeof(int64);
-    case zfp_type_float:
-      return CHAR_BIT * (uint)sizeof(float);
-    case zfp_type_double:
-      return CHAR_BIT * (uint)sizeof(double);
-    default:
-      return 0;
-  }
-}
-
-static int
-is_reversible(const zfp_stream* zfp)
-{
-  return zfp->minexp < ZFP_MIN_EXP;
-}
-
-/* shared code across template instances ------------------------------------*/
-
-#include "share/parallel.c"
-#include "share/omp.c"
-
-/* template instantiation of integer and float compressor -------------------*/
-
-#define Scalar int32
-#include "template/compress.c"
-#include "template/decompress.c"
-#include "template/ompcompress.c"
-#include "template/cudacompress.c"
-#include "template/cudadecompress.c"
-#undef Scalar
-
-#define Scalar int64
-#include "template/compress.c"
-#include "template/decompress.c"
-#include "template/ompcompress.c"
-#include "template/cudacompress.c"
-#include "template/cudadecompress.c"
-#undef Scalar
-
-#define Scalar float
-#include "template/compress.c"
-#include "template/decompress.c"
-#include "template/ompcompress.c"
-#include "template/cudacompress.c"
-#include "template/cudadecompress.c"
-#undef Scalar
-
-#define Scalar double
-#include "template/compress.c"
-#include "template/decompress.c"
-#include "template/ompcompress.c"
-#include "template/cudacompress.c"
-#include "template/cudadecompress.c"
-#undef Scalar
-
-/* public functions: miscellaneous ----------------------------------------- */
-
-size_t
-zfp_type_size(zfp_type type)
-{
-  switch (type) {
-    case zfp_type_int32:
-      return sizeof(int32);
-    case zfp_type_int64:
-      return sizeof(int64);
-    case zfp_type_float:
-      return sizeof(float);
-    case zfp_type_double:
-      return sizeof(double);
-    default:
-      return 0;
-  }
-}
-
-/* public functions: fields ------------------------------------------------ */
-
-zfp_field*
-zfp_field_alloc()
-{
-  zfp_field* field = (zfp_field*)malloc(sizeof(zfp_field));
-  if (field) {
-    field->type = zfp_type_none;
-    field->nx = field->ny = field->nz = field->nw = 0;
-    field->sx = field->sy = field->sz = field->sw = 0;
-    field->data = 0;
-  }
-  return field;
-}
-
-zfp_field*
-zfp_field_1d(void* data, zfp_type type, uint nx)
-{
-  zfp_field* field = zfp_field_alloc();
-  if (field) {
-    field->type = type;
-    field->nx = nx;
-    field->data = data;
-  }
-  return field;
-}
-
-zfp_field*
-zfp_field_2d(void* data, zfp_type type, uint nx, uint ny)
-{
-  zfp_field* field = zfp_field_alloc();
-  if (field) {
-    field->type = type;
-    field->nx = nx;
-    field->ny = ny;
-    field->data = data;
-  }
-  return field;
-}
-
-zfp_field*
-zfp_field_3d(void* data, zfp_type type, uint nx, uint ny, uint nz)
-{
-  zfp_field* field = zfp_field_alloc();
-  if (field) {
-    field->type = type;
-    field->nx = nx;
-    field->ny = ny;
-    field->nz = nz;
-    field->data = data;
-  }
-  return field;
-}
-
-zfp_field*
-zfp_field_4d(void* data, zfp_type type, uint nx, uint ny, uint nz, uint nw)
-{
-  zfp_field* field = zfp_field_alloc();
-  if (field) {
-    field->type = type;
-    field->nx = nx;
-    field->ny = ny;
-    field->nz = nz;
-    field->nw = nw;
-    field->data = data;
-  }
-  return field;
-}
-
-void
-zfp_field_free(zfp_field* field)
-{
-  free(field);
-}
-
-void*
-zfp_field_pointer(const zfp_field* field)
-{
-  return field->data;
-}
-
-zfp_type
-zfp_field_type(const zfp_field* field)
-{
-  return field->type;
-}
-
-uint
-zfp_field_precision(const zfp_field* field)
-{
-  return type_precision(field->type);
-}
-
-uint
-zfp_field_dimensionality(const zfp_field* field)
-{
-  return field->nx ? field->ny ? field->nz ? field->nw ? 4 : 3 : 2 : 1 : 0;
-}
-
-size_t
-zfp_field_size(const zfp_field* field, uint* size)
-{
-  if (size)
-    switch (zfp_field_dimensionality(field)) {
-      case 4:
-        size[3] = field->nw;
-        /* FALLTHROUGH */
-      case 3:
-        size[2] = field->nz;
-        /* FALLTHROUGH */
-      case 2:
-        size[1] = field->ny;
-        /* FALLTHROUGH */
-      case 1:
-        size[0] = field->nx;
-        break;
-    }
-  return (size_t)MAX(field->nx, 1u) * (size_t)MAX(field->ny, 1u) * (size_t)MAX(field->nz, 1u) * (size_t)MAX(field->nw, 1u);
-}
-
-int
-zfp_field_stride(const zfp_field* field, int* stride)
-{
-  if (stride)
-    switch (zfp_field_dimensionality(field)) {
-      case 4:
-        stride[3] = field->sw ? field->sw : (int)(field->nx * field->ny * field->nz);
-        /* FALLTHROUGH */
-      case 3:
-        stride[2] = field->sz ? field->sz : (int)(field->nx * field->ny);
-        /* FALLTHROUGH */
-      case 2:
-        stride[1] = field->sy ? field->sy : (int)field->nx;
-        /* FALLTHROUGH */
-      case 1:
-        stride[0] = field->sx ? field->sx : 1;
-        break;
-    }
-  return field->sx || field->sy || field->sz || field->sw;
-}
-
-uint64
-zfp_field_metadata(const zfp_field* field)
-{
-  uint64 meta = 0;
-  /* 48 bits for dimensions */
-  switch (zfp_field_dimensionality(field)) {
-    case 1:
-      if ((uint64)(field->nx - 1) >> 48)
-        return ZFP_META_NULL;
-      meta <<= 48; meta += field->nx - 1;
-      break;
-    case 2:
-      if (((field->nx - 1) >> 24) ||
-          ((field->ny - 1) >> 24))
-        return ZFP_META_NULL;
-      meta <<= 24; meta += field->ny - 1;
-      meta <<= 24; meta += field->nx - 1;
-      break;
-    case 3:
-      if (((field->nx - 1) >> 16) ||
-          ((field->ny - 1) >> 16) ||
-          ((field->nz - 1) >> 16))
-        return ZFP_META_NULL;
-      meta <<= 16; meta += field->nz - 1;
-      meta <<= 16; meta += field->ny - 1;
-      meta <<= 16; meta += field->nx - 1;
-      break;
-    case 4:
-      if (((field->nx - 1) >> 12) ||
-          ((field->ny - 1) >> 12) ||
-          ((field->nz - 1) >> 12) ||
-          ((field->nw - 1) >> 12))
-        return ZFP_META_NULL;
-      meta <<= 12; meta += field->nw - 1;
-      meta <<= 12; meta += field->nz - 1;
-      meta <<= 12; meta += field->ny - 1;
-      meta <<= 12; meta += field->nx - 1;
-      break;
-  }
-  /* 2 bits for dimensionality (1D, 2D, 3D, 4D) */
-  meta <<= 2; meta += zfp_field_dimensionality(field) - 1;
-  /* 2 bits for scalar type */
-  meta <<= 2; meta += field->type - 1;
-  return meta;
-}
-
-void
-zfp_field_set_pointer(zfp_field* field, void* data)
-{
-  field->data = data;
-}
-
-zfp_type
-zfp_field_set_type(zfp_field* field, zfp_type type)
-{
-  switch (type) {
-    case zfp_type_int32:
-    case zfp_type_int64:
-    case zfp_type_float:
-    case zfp_type_double:
-      field->type = type;
-      return type;
-    default:
-      return zfp_type_none;
-  }
-}
-
-void
-zfp_field_set_size_1d(zfp_field* field, uint n)
-{
-  field->nx = n;
-  field->ny = 0;
-  field->nz = 0;
-  field->nw = 0;
-}
-
-void
-zfp_field_set_size_2d(zfp_field* field, uint nx, uint ny)
-{
-  field->nx = nx;
-  field->ny = ny;
-  field->nz = 0;
-  field->nw = 0;
-}
-
-void
-zfp_field_set_size_3d(zfp_field* field, uint nx, uint ny, uint nz)
-{
-  field->nx = nx;
-  field->ny = ny;
-  field->nz = nz;
-  field->nw = 0;
-}
-
-void
-zfp_field_set_size_4d(zfp_field* field, uint nx, uint ny, uint nz, uint nw)
-{
-  field->nx = nx;
-  field->ny = ny;
-  field->nz = nz;
-  field->nw = nw;
-}
-
-void
-zfp_field_set_stride_1d(zfp_field* field, int sx)
-{
-  field->sx = sx;
-  field->sy = 0;
-  field->sz = 0;
-  field->sw = 0;
-}
-
-void
-zfp_field_set_stride_2d(zfp_field* field, int sx, int sy)
-{
-  field->sx = sx;
-  field->sy = sy;
-  field->sz = 0;
-  field->sw = 0;
-}
-
-void
-zfp_field_set_stride_3d(zfp_field* field, int sx, int sy, int sz)
-{
-  field->sx = sx;
-  field->sy = sy;
-  field->sz = sz;
-  field->sw = 0;
-}
-
-void
-zfp_field_set_stride_4d(zfp_field* field, int sx, int sy, int sz, int sw)
-{
-  field->sx = sx;
-  field->sy = sy;
-  field->sz = sz;
-  field->sw = sw;
-}
-
-int
-zfp_field_set_metadata(zfp_field* field, uint64 meta)
-{
-  uint64 dims;
-  /* ensure value is in range */
-  if (meta >> ZFP_META_BITS)
-    return 0;
-  field->type = (zfp_type)((meta & 0x3u) + 1); meta >>= 2;
-  dims = (meta & 0x3u) + 1; meta >>= 2;
-  switch (dims) {
-    case 1:
-      /* currently dimensions are limited to 2^32 - 1 */
-      field->nx = (meta & UINT64C(0x0000ffffffff)) + 1; meta >>= 48;
-      field->ny = 0;
-      field->nz = 0;
-      field->nw = 0;
-      break;
-    case 2:
-      field->nx = (meta & UINT64C(0xffffff)) + 1; meta >>= 24;
-      field->ny = (meta & UINT64C(0xffffff)) + 1; meta >>= 24;
-      field->nz = 0;
-      field->nw = 0;
-      break;
-    case 3:
-      field->nx = (meta & UINT64C(0xffff)) + 1; meta >>= 16;
-      field->ny = (meta & UINT64C(0xffff)) + 1; meta >>= 16;
-      field->nz = (meta & UINT64C(0xffff)) + 1; meta >>= 16;
-      field->nw = 0;
-      break;
-    case 4:
-      field->nx = (meta & UINT64C(0xfff)) + 1; meta >>= 12;
-      field->ny = (meta & UINT64C(0xfff)) + 1; meta >>= 12;
-      field->nz = (meta & UINT64C(0xfff)) + 1; meta >>= 12;
-      field->nw = (meta & UINT64C(0xfff)) + 1; meta >>= 12;
-      break;
-  }
-  field->sx = field->sy = field->sz = field->sw = 0;
-  return 1;
-}
-
-/* public functions: zfp compressed stream --------------------------------- */
-
-zfp_stream*
-zfp_stream_open(bitstream* stream)
-{
-  zfp_stream* zfp = (zfp_stream*)malloc(sizeof(zfp_stream));
-  if (zfp) {
-    zfp->stream = stream;
-    zfp->minbits = ZFP_MIN_BITS;
-    zfp->maxbits = ZFP_MAX_BITS;
-    zfp->maxprec = ZFP_MAX_PREC;
-    zfp->minexp = ZFP_MIN_EXP;
-    zfp->exec.policy = zfp_exec_serial;
-  }
-  return zfp;
-}
-
-void
-zfp_stream_close(zfp_stream* zfp)
-{
-  free(zfp);
-}
-
-bitstream*
-zfp_stream_bit_stream(const zfp_stream* zfp)
-{
-  return zfp->stream;
-}
-
-zfp_mode
-zfp_stream_compression_mode(const zfp_stream* zfp)
-{
-  if (zfp->minbits > zfp->maxbits || !(0 < zfp->maxprec && zfp->maxprec <= 64))
-    return zfp_mode_null;
-
-  /* default values are considered expert mode */
-  if (zfp->minbits == ZFP_MIN_BITS &&
-      zfp->maxbits == ZFP_MAX_BITS &&
-      zfp->maxprec == ZFP_MAX_PREC &&
-      zfp->minexp == ZFP_MIN_EXP)
-    return zfp_mode_expert;
-
-  /* fixed rate? */
-  if (zfp->minbits == zfp->maxbits &&
-      1 <= zfp->maxbits && zfp->maxbits <= ZFP_MAX_BITS &&
-      zfp->maxprec >= ZFP_MAX_PREC &&
-      zfp->minexp == ZFP_MIN_EXP)
-    return zfp_mode_fixed_rate;
-
-  /* fixed precision? */
-  if (zfp->minbits <= ZFP_MIN_BITS &&
-      zfp->maxbits >= ZFP_MAX_BITS &&
-      zfp->maxprec >= 1 &&
-      zfp->minexp == ZFP_MIN_EXP)
-    return zfp_mode_fixed_precision;
-
-  /* fixed accuracy? */
-  if (zfp->minbits <= ZFP_MIN_BITS &&
-      zfp->maxbits >= ZFP_MAX_BITS &&
-      zfp->maxprec >= ZFP_MAX_PREC &&
-      zfp->minexp >= ZFP_MIN_EXP)
-    return zfp_mode_fixed_accuracy;
-
-  /* reversible? */
-  if (zfp->minbits <= ZFP_MIN_BITS &&
-      zfp->maxbits >= ZFP_MAX_BITS &&
-      zfp->maxprec >= ZFP_MAX_PREC &&
-      zfp->minexp < ZFP_MIN_EXP)
-    return zfp_mode_reversible;
-
-  return zfp_mode_expert;
-}
-
-uint64
-zfp_stream_mode(const zfp_stream* zfp)
-{
-  uint64 mode = 0;
-  uint minbits;
-  uint maxbits;
-  uint maxprec;
-  uint minexp;
-
-  /* common configurations mapped to short representation */
-  switch (zfp_stream_compression_mode(zfp)) {
-    case zfp_mode_fixed_rate:
-      if (zfp->maxbits <= 2048)
-        /* maxbits is [1, 2048] */
-        /* returns [0, 2047] */
-        return (zfp->maxbits - 1);
-      else
-        break;
-
-    case zfp_mode_fixed_precision:
-      if (zfp->maxprec <= 128)
-        /* maxprec is [1, 128] */
-        /* returns [2048, 2175] */
-        return (zfp->maxprec - 1) + (2048);
-      else
-        break;
-
-    case zfp_mode_fixed_accuracy:
-      if (zfp->minexp <= 843)
-        /* minexp is [ZFP_MIN_EXP=-1074, 843] */
-        /* returns [2177, ZFP_MODE_SHORT_MAX=4094] */
-        /* +1 because skipped 2176 */
-        return (zfp->minexp - ZFP_MIN_EXP) + (2048 + 128 + 1);
-      else
-        break;
-
-    case zfp_mode_reversible:
-      /* returns 2176 */
-      return 2048 + 128;
-
-    default:
-      break;
-  }
-
-  /* encode each parameter separately */
-  minbits = MAX(1, MIN(zfp->minbits, 0x8000u)) - 1;
-  maxbits = MAX(1, MIN(zfp->maxbits, 0x8000u)) - 1;
-  maxprec = MAX(1, MIN(zfp->maxprec, 0x0080u)) - 1;
-  minexp = MAX(0, MIN(zfp->minexp + 16495, 0x7fff));
-  mode <<= 15; mode += minexp;
-  mode <<=  7; mode += maxprec;
-  mode <<= 15; mode += maxbits;
-  mode <<= 15; mode += minbits;
-  mode <<= 12; mode += 0xfffu;
-
-  return mode;
-}
-
-void
-zfp_stream_params(const zfp_stream* zfp, uint* minbits, uint* maxbits, uint* maxprec, int* minexp)
-{
-  if (minbits)
-    *minbits = zfp->minbits;
-  if (maxbits)
-    *maxbits = zfp->maxbits;
-  if (maxprec)
-    *maxprec = zfp->maxprec;
-  if (minexp)
-    *minexp = zfp->minexp;
-}
-
-size_t
-zfp_stream_compressed_size(const zfp_stream* zfp)
-{
-  return stream_size(zfp->stream);
-}
-
-size_t
-zfp_stream_maximum_size(const zfp_stream* zfp, const zfp_field* field)
-{
-  uint dims = zfp_field_dimensionality(field);
-  uint mx = (MAX(field->nx, 1u) + 3) / 4;
-  uint my = (MAX(field->ny, 1u) + 3) / 4;
-  uint mz = (MAX(field->nz, 1u) + 3) / 4;
-  uint mw = (MAX(field->nw, 1u) + 3) / 4;
-  size_t blocks = (size_t)mx * (size_t)my * (size_t)mz * (size_t)mw;
-  uint values = 1u << (2 * dims);
-  uint maxbits = 1;
-
-  if (!dims)
-    return 0;
-  switch (field->type) {
-    case zfp_type_none:
-      return 0;
-    case zfp_type_float:
-      maxbits += 8;
-      if (is_reversible(zfp))
-        maxbits += 5;
-      break;
-    case zfp_type_double:
-      maxbits += 11;
-      if (is_reversible(zfp))
-        maxbits += 6;
-      break;
-    default:
-      break;
-  }
-  maxbits += values - 1 + values * MIN(zfp->maxprec, type_precision(field->type));
-  maxbits = MIN(maxbits, zfp->maxbits);
-  maxbits = MAX(maxbits, zfp->minbits);
-  return ((ZFP_HEADER_MAX_BITS + blocks * maxbits + stream_word_bits - 1) & ~(stream_word_bits - 1)) / CHAR_BIT;
-}
-
-void
-zfp_stream_set_bit_stream(zfp_stream* zfp, bitstream* stream)
-{
-  zfp->stream = stream;
-}
-
-void
-zfp_stream_set_reversible(zfp_stream* zfp)
-{
-  zfp->minbits = ZFP_MIN_BITS;
-  zfp->maxbits = ZFP_MAX_BITS;
-  zfp->maxprec = ZFP_MAX_PREC;
-  zfp->minexp = ZFP_MIN_EXP - 1;
-}
-
-double
-zfp_stream_set_rate(zfp_stream* zfp, double rate, zfp_type type, uint dims, int wra)
-{
-  uint n = 1u << (2 * dims);
-  uint bits = (uint)floor(n * rate + 0.5);
-  switch (type) {
-    case zfp_type_float:
-      bits = MAX(bits, 1 + 8u);
-      break;
-    case zfp_type_double:
-      bits = MAX(bits, 1 + 11u);
-      break;
-    default:
-      break;
-  }
-  if (wra) {
-    /* for write random access, round up to next multiple of stream word size */
-    bits += (uint)stream_word_bits - 1;
-    bits &= ~(stream_word_bits - 1);
-  }
-  zfp->minbits = bits;
-  zfp->maxbits = bits;
-  zfp->maxprec = ZFP_MAX_PREC;
-  zfp->minexp = ZFP_MIN_EXP;
-  return (double)bits / n;
-}
-
-uint
-zfp_stream_set_precision(zfp_stream* zfp, uint precision)
-{
-  zfp->minbits = ZFP_MIN_BITS;
-  zfp->maxbits = ZFP_MAX_BITS;
-  zfp->maxprec = precision ? MIN(precision, ZFP_MAX_PREC) : ZFP_MAX_PREC;
-  zfp->minexp = ZFP_MIN_EXP;
-  return zfp->maxprec;
-}
-
-double
-zfp_stream_set_accuracy(zfp_stream* zfp, double tolerance)
-{
-  int emin = ZFP_MIN_EXP;
-  if (tolerance > 0) {
-    /* tolerance = x * 2^emin, with 0.5 <= x < 1 */
-    frexp(tolerance, &emin);
-    emin--;
-    /* assert: 2^emin <= tolerance < 2^(emin+1) */
-  }
-  zfp->minbits = ZFP_MIN_BITS;
-  zfp->maxbits = ZFP_MAX_BITS;
-  zfp->maxprec = ZFP_MAX_PREC;
-  zfp->minexp = emin;
-  return tolerance > 0 ? ldexp(1.0, emin) : 0;
-}
-
-zfp_mode
-zfp_stream_set_mode(zfp_stream* zfp, uint64 mode)
-{
-  uint minbits, maxbits, maxprec;
-  int minexp;
-
-  if (mode <= ZFP_MODE_SHORT_MAX) {
-    /* 12-bit (short) encoding of one of four modes */
-    if (mode < 2048) {
-      /* fixed rate */
-      minbits = maxbits = (uint)mode + 1;
-      maxprec = ZFP_MAX_PREC;
-      minexp = ZFP_MIN_EXP;
-    }
-    else if (mode < (2048 + 128)) {
-      /* fixed precision */
-      minbits = ZFP_MIN_BITS;
-      maxbits = ZFP_MAX_BITS;
-      maxprec = (uint)mode + 1 - (2048);
-      minexp = ZFP_MIN_EXP;
-    }
-    else if (mode == (2048 + 128)) {
-      /* reversible */
-      minbits = ZFP_MIN_BITS;
-      maxbits = ZFP_MAX_BITS;
-      maxprec = ZFP_MAX_PREC;
-      minexp = ZFP_MIN_EXP - 1;
-    }
-    else {
-      /* fixed accuracy */
-      minbits = ZFP_MIN_BITS;
-      maxbits = ZFP_MAX_BITS;
-      maxprec = ZFP_MAX_PREC;
-      minexp = (uint)mode + ZFP_MIN_EXP - (2048 + 128 + 1);
-    }
-  }
-  else {
-    /* 64-bit encoding */
-    mode >>= 12; minbits = ((uint)mode & 0x7fffu) + 1;
-    mode >>= 15; maxbits = ((uint)mode & 0x7fffu) + 1;
-    mode >>= 15; maxprec = ((uint)mode & 0x007fu) + 1;
-    mode >>=  7; minexp  = ((uint)mode & 0x7fffu) - 16495;
-  }
-
-  if (!zfp_stream_set_params(zfp, minbits, maxbits, maxprec, minexp))
-    return zfp_mode_null;
-
-  return zfp_stream_compression_mode(zfp);
-}
-
-int
-zfp_stream_set_params(zfp_stream* zfp, uint minbits, uint maxbits, uint maxprec, int minexp)
-{
-  if (minbits > maxbits || !(0 < maxprec && maxprec <= 64))
-    return 0;
-  zfp->minbits = minbits;
-  zfp->maxbits = maxbits;
-  zfp->maxprec = maxprec;
-  zfp->minexp = minexp;
-  return 1;
-}
-
-size_t
-zfp_stream_flush(zfp_stream* zfp)
-{
-  return stream_flush(zfp->stream);
-}
-
-size_t
-zfp_stream_align(zfp_stream* zfp)
-{
-  return stream_align(zfp->stream);
-}
-
-void
-zfp_stream_rewind(zfp_stream* zfp)
-{
-  stream_rewind(zfp->stream);
-}
-
-/* public functions: execution policy -------------------------------------- */
-
-zfp_exec_policy
-zfp_stream_execution(const zfp_stream* zfp)
-{
-  return zfp->exec.policy;
-}
-
-uint
-zfp_stream_omp_threads(const zfp_stream* zfp)
-{
-  return zfp->exec.params.omp.threads;
-}
-
-uint
-zfp_stream_omp_chunk_size(const zfp_stream* zfp)
-{
-  return zfp->exec.params.omp.chunk_size;
-}
-
-int
-zfp_stream_set_execution(zfp_stream* zfp, zfp_exec_policy policy)
-{
-  switch (policy) {
-    case zfp_exec_serial:
-      break;
-#ifdef ZFP_WITH_CUDA
-    case zfp_exec_cuda:
-      break;
-#endif
-    case zfp_exec_omp:
-#ifdef _OPENMP
-      if (zfp->exec.policy != policy) {
-        zfp->exec.params.omp.threads = 0;
-        zfp->exec.params.omp.chunk_size = 0;
-      }
-      break;
-#else
-      return 0;
-#endif
-    default:
-      return 0;
-  }
-  zfp->exec.policy = policy;
-  return 1;
-}
-
-int
-zfp_stream_set_omp_threads(zfp_stream* zfp, uint threads)
-{
-  if (!zfp_stream_set_execution(zfp, zfp_exec_omp))
-    return 0;
-  zfp->exec.params.omp.threads = threads;
-  return 1;
-}
-
-int
-zfp_stream_set_omp_chunk_size(zfp_stream* zfp, uint chunk_size)
-{
-  if (!zfp_stream_set_execution(zfp, zfp_exec_omp))
-    return 0;
-  zfp->exec.params.omp.chunk_size = chunk_size;
-  return 1;
-}
-
-/* public functions: utility functions --------------------------------------*/
-
-void
-zfp_promote_int8_to_int32(int32* oblock, const int8* iblock, uint dims)
-{
-  uint count = 1u << (2 * dims);
-  while (count--)
-    *oblock++ = (int32)*iblock++ << 23;
-}
-
-void
-zfp_promote_uint8_to_int32(int32* oblock, const uint8* iblock, uint dims)
-{
-  uint count = 1u << (2 * dims);
-  while (count--)
-    *oblock++ = ((int32)*iblock++ - 0x80) << 23;
-}
-
-void
-zfp_promote_int16_to_int32(int32* oblock, const int16* iblock, uint dims)
-{
-  uint count = 1u << (2 * dims);
-  while (count--)
-    *oblock++ = (int32)*iblock++ << 15;
-}
-
-void
-zfp_promote_uint16_to_int32(int32* oblock, const uint16* iblock, uint dims)
-{
-  uint count = 1u << (2 * dims);
-  while (count--)
-    *oblock++ = ((int32)*iblock++ - 0x8000) << 15;
-}
-
-void
-zfp_demote_int32_to_int8(int8* oblock, const int32* iblock, uint dims)
-{
-  uint count = 1u << (2 * dims);
-  while (count--) {
-    int32 i = *iblock++ >> 23;
-    *oblock++ = (int8)MAX(-0x80, MIN(i, 0x7f));
-  }
-}
-
-void
-zfp_demote_int32_to_uint8(uint8* oblock, const int32* iblock, uint dims)
-{
-  uint count = 1u << (2 * dims);
-  while (count--) {
-    int32 i = (*iblock++ >> 23) + 0x80;
-    *oblock++ = (uint8)MAX(0x00, MIN(i, 0xff));
-  }
-}
-
-void
-zfp_demote_int32_to_int16(int16* oblock, const int32* iblock, uint dims)
-{
-  uint count = 1u << (2 * dims);
-  while (count--) {
-    int32 i = *iblock++ >> 15;
-    *oblock++ = (int16)MAX(-0x8000, MIN(i, 0x7fff));
-  }
-}
-
-void
-zfp_demote_int32_to_uint16(uint16* oblock, const int32* iblock, uint dims)
-{
-  uint count = 1u << (2 * dims);
-  while (count--) {
-    int32 i = (*iblock++ >> 15) + 0x8000;
-    *oblock++ = (uint16)MAX(0x0000, MIN(i, 0xffff));
-  }
-}
-
-/* public functions: compression and decompression --------------------------*/
-
-size_t
-zfp_compress(zfp_stream* zfp, const zfp_field* field)
-{
-  /* function table [execution][strided][dimensionality][scalar type] */
-  void (*ftable[3][2][4][4])(zfp_stream*, const zfp_field*) = {
-    /* serial */
-    {{{ compress_int32_1,         compress_int64_1,         compress_float_1,         compress_double_1 },
-      { compress_strided_int32_2, compress_strided_int64_2, compress_strided_float_2, compress_strided_double_2 },
-      { compress_strided_int32_3, compress_strided_int64_3, compress_strided_float_3, compress_strided_double_3 },
-      { compress_strided_int32_4, compress_strided_int64_4, compress_strided_float_4, compress_strided_double_4 }},
-     {{ compress_strided_int32_1, compress_strided_int64_1, compress_strided_float_1, compress_strided_double_1 },
-      { compress_strided_int32_2, compress_strided_int64_2, compress_strided_float_2, compress_strided_double_2 },
-      { compress_strided_int32_3, compress_strided_int64_3, compress_strided_float_3, compress_strided_double_3 },
-      { compress_strided_int32_4, compress_strided_int64_4, compress_strided_float_4, compress_strided_double_4 }}},
-
-    /* OpenMP */
-#ifdef _OPENMP
-    {{{ compress_omp_int32_1,         compress_omp_int64_1,         compress_omp_float_1,         compress_omp_double_1 },
-      { compress_strided_omp_int32_2, compress_strided_omp_int64_2, compress_strided_omp_float_2, compress_strided_omp_double_2 },
-      { compress_strided_omp_int32_3, compress_strided_omp_int64_3, compress_strided_omp_float_3, compress_strided_omp_double_3 },
-      { compress_strided_omp_int32_4, compress_strided_omp_int64_4, compress_strided_omp_float_4, compress_strided_omp_double_4 }},
-     {{ compress_strided_omp_int32_1, compress_strided_omp_int64_1, compress_strided_omp_float_1, compress_strided_omp_double_1 },
-      { compress_strided_omp_int32_2, compress_strided_omp_int64_2, compress_strided_omp_float_2, compress_strided_omp_double_2 },
-      { compress_strided_omp_int32_3, compress_strided_omp_int64_3, compress_strided_omp_float_3, compress_strided_omp_double_3 },
-      { compress_strided_omp_int32_4, compress_strided_omp_int64_4, compress_strided_omp_float_4, compress_strided_omp_double_4 }}},
-#else
-    {{{ NULL }}},
-#endif
-
-    /* CUDA */
-#ifdef ZFP_WITH_CUDA
-    {{{ compress_cuda_int32_1,         compress_cuda_int64_1,         compress_cuda_float_1,         compress_cuda_double_1 },
-      { compress_strided_cuda_int32_2, compress_strided_cuda_int64_2, compress_strided_cuda_float_2, compress_strided_cuda_double_2 },
-      { compress_strided_cuda_int32_3, compress_strided_cuda_int64_3, compress_strided_cuda_float_3, compress_strided_cuda_double_3 },
-      { NULL,                            NULL,                            NULL,                            NULL }},
-     {{ compress_strided_cuda_int32_1, compress_strided_cuda_int64_1, compress_strided_cuda_float_1, compress_strided_cuda_double_1 },
-      { compress_strided_cuda_int32_2, compress_strided_cuda_int64_2, compress_strided_cuda_float_2, compress_strided_cuda_double_2 },
-      { compress_strided_cuda_int32_3, compress_strided_cuda_int64_3, compress_strided_cuda_float_3, compress_strided_cuda_double_3 },
-      { NULL,                            NULL,                            NULL,                            NULL }}},
-#else
-    {{{ NULL }}},
-#endif
-  };
-  uint exec = zfp->exec.policy;
-  uint strided = zfp_field_stride(field, NULL);
-  uint dims = zfp_field_dimensionality(field);
-  uint type = field->type;
-  void (*compress)(zfp_stream*, const zfp_field*);
-
-  switch (type) {
-    case zfp_type_int32:
-    case zfp_type_int64:
-    case zfp_type_float:
-    case zfp_type_double:
-      break;
-    default:
-      return 0;
-  }
-
-  /* return 0 if compression mode is not supported */
-  compress = ftable[exec][strided][dims - 1][type - zfp_type_int32];
-  if (!compress)
-    return 0;
-
-  /* compress field and align bit stream on word boundary */
-  compress(zfp, field);
-  stream_flush(zfp->stream);
-
-  return stream_size(zfp->stream);
-}
-
-size_t
-zfp_decompress(zfp_stream* zfp, zfp_field* field)
-{
-  /* function table [execution][strided][dimensionality][scalar type] */
-  void (*ftable[3][2][4][4])(zfp_stream*, zfp_field*) = {
-    /* serial */
-    {{{ decompress_int32_1,         decompress_int64_1,         decompress_float_1,         decompress_double_1 },
-      { decompress_strided_int32_2, decompress_strided_int64_2, decompress_strided_float_2, decompress_strided_double_2 },
-      { decompress_strided_int32_3, decompress_strided_int64_3, decompress_strided_float_3, decompress_strided_double_3 },
-      { decompress_strided_int32_4, decompress_strided_int64_4, decompress_strided_float_4, decompress_strided_double_4 }},
-     {{ decompress_strided_int32_1, decompress_strided_int64_1, decompress_strided_float_1, decompress_strided_double_1 },
-      { decompress_strided_int32_2, decompress_strided_int64_2, decompress_strided_float_2, decompress_strided_double_2 },
-      { decompress_strided_int32_3, decompress_strided_int64_3, decompress_strided_float_3, decompress_strided_double_3 },
-      { decompress_strided_int32_4, decompress_strided_int64_4, decompress_strided_float_4, decompress_strided_double_4 }}},
-
-    /* OpenMP; not yet supported */
-    {{{ NULL }}},
-
-    /* CUDA */
-#ifdef ZFP_WITH_CUDA
-    {{{ decompress_cuda_int32_1,         decompress_cuda_int64_1,         decompress_cuda_float_1,         decompress_cuda_double_1 },
-      { decompress_strided_cuda_int32_2, decompress_strided_cuda_int64_2, decompress_strided_cuda_float_2, decompress_strided_cuda_double_2 },
-      { decompress_strided_cuda_int32_3, decompress_strided_cuda_int64_3, decompress_strided_cuda_float_3, decompress_strided_cuda_double_3 },
-      { NULL,                            NULL,                            NULL,                            NULL }},
-     {{ decompress_strided_cuda_int32_1, decompress_strided_cuda_int64_1, decompress_strided_cuda_float_1, decompress_strided_cuda_double_1 },
-      { decompress_strided_cuda_int32_2, decompress_strided_cuda_int64_2, decompress_strided_cuda_float_2, decompress_strided_cuda_double_2 },
-      { decompress_strided_cuda_int32_3, decompress_strided_cuda_int64_3, decompress_strided_cuda_float_3, decompress_strided_cuda_double_3 },
-      { NULL,                            NULL,                            NULL,                            NULL }}},
-#else
-    {{{ NULL }}},
-#endif
-  };
-  uint exec = zfp->exec.policy;
-  uint strided = zfp_field_stride(field, NULL);
-  uint dims = zfp_field_dimensionality(field);
-  uint type = field->type;
-  void (*decompress)(zfp_stream*, zfp_field*);
-
-  switch (type) {
-    case zfp_type_int32:
-    case zfp_type_int64:
-    case zfp_type_float:
-    case zfp_type_double:
-      break;
-    default:
-      return 0;
-  }
-
-  /* return 0 if decompression mode is not supported */
-  decompress = ftable[exec][strided][dims - 1][type - zfp_type_int32];
-  if (!decompress)
-    return 0;
-
-  /* decompress field and align bit stream on word boundary */
-  decompress(zfp, field);
-  stream_align(zfp->stream);
-
-  return stream_size(zfp->stream);
-}
-
-size_t
-zfp_write_header(zfp_stream* zfp, const zfp_field* field, uint mask)
-{
-  size_t bits = 0;
-  uint64 meta = 0;
-
-  /* first make sure field dimensions fit in header */
-  if (mask & ZFP_HEADER_META) {
-    meta = zfp_field_metadata(field);
-    if (meta == ZFP_META_NULL)
-      return 0;
-  }
-
-  /* 32-bit magic */
-  if (mask & ZFP_HEADER_MAGIC) {
-    stream_write_bits(zfp->stream, 'z', 8);
-    stream_write_bits(zfp->stream, 'f', 8);
-    stream_write_bits(zfp->stream, 'p', 8);
-    stream_write_bits(zfp->stream, zfp_codec_version, 8);
-    bits += ZFP_MAGIC_BITS;
-  }
-  /* 52-bit field metadata */
-  if (mask & ZFP_HEADER_META) {
-    stream_write_bits(zfp->stream, meta, ZFP_META_BITS);
-    bits += ZFP_META_BITS;
-  }
-  /* 12- or 64-bit compression parameters */
-  if (mask & ZFP_HEADER_MODE) {
-    uint64 mode = zfp_stream_mode(zfp);
-    uint size = mode > ZFP_MODE_SHORT_MAX ? ZFP_MODE_LONG_BITS : ZFP_MODE_SHORT_BITS;
-    stream_write_bits(zfp->stream, mode, size);
-    bits += size;
-  }
-
-  return bits;
-}
-
-size_t
-zfp_read_header(zfp_stream* zfp, zfp_field* field, uint mask)
-{
-  size_t bits = 0;
-  if (mask & ZFP_HEADER_MAGIC) {
-    if (stream_read_bits(zfp->stream, 8) != 'z' ||
-        stream_read_bits(zfp->stream, 8) != 'f' ||
-        stream_read_bits(zfp->stream, 8) != 'p' ||
-        stream_read_bits(zfp->stream, 8) != zfp_codec_version)
-      return 0;
-    bits += ZFP_MAGIC_BITS;
-  }
-  if (mask & ZFP_HEADER_META) {
-    uint64 meta = stream_read_bits(zfp->stream, ZFP_META_BITS);
-    if (!zfp_field_set_metadata(field, meta))
-      return 0;
-    bits += ZFP_META_BITS;
-  }
-  if (mask & ZFP_HEADER_MODE) {
-    uint64 mode = stream_read_bits(zfp->stream, ZFP_MODE_SHORT_BITS);
-    bits += ZFP_MODE_SHORT_BITS;
-    if (mode > ZFP_MODE_SHORT_MAX) {
-      uint size = ZFP_MODE_LONG_BITS - ZFP_MODE_SHORT_BITS;
-      mode += stream_read_bits(zfp->stream, size) << ZFP_MODE_SHORT_BITS;
-      bits += size;
-    }
-    if (zfp_stream_set_mode(zfp, mode) == zfp_mode_null)
-      return 0;
-  }
-  return bits;
-}