/*
 * This file provides the implementation of atc.h.
 * 
 * Disclaimer: This file was automatically generated using tools/code_generator.py.
 * If you want to change this file as a part of a library modification, the aforementioned script should be changed and re-run instead.
 */

#include "atc.h"
#include "atc.hpp"
#include "util-c.hpp"

bool atc_compress_ff(const char* original_file, atc_data_type data_type, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { atc::compress(convert_string(original_file), convert_data_type(data_type), convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
bool atc_compress_ff_options(const char* original_file, atc_data_type data_type, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress(convert_string(original_file), convert_data_type(data_type), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
atc_results atc_compress_ff_results(const char* original_file, atc_data_type data_type, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { return atc::compress(convert_string(original_file), convert_data_type(data_type), convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
atc_results atc_compress_ff_results_options(const char* original_file, atc_data_type data_type, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(convert_string(original_file), convert_data_type(data_type), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
atc_results atc_compress_fm_results(const char* original_file, atc_data_type data_type, uint8_t modes, const size_t* sizes, double target_error) {
	return wrap_evaluation([&] () { return atc::compress(convert_string(original_file), convert_data_type(data_type), convert_sizes(modes, sizes), target_error); });
}
atc_results atc_compress_fm_results_options(const char* original_file, atc_data_type data_type, uint8_t modes, const size_t* sizes, double target_error, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(convert_string(original_file), convert_data_type(data_type), convert_sizes(modes, sizes), target_error, convert_options(options)); });
}
bool atc_compress_mf_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
bool atc_compress_mf_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
bool atc_compress_mf_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
bool atc_compress_mf_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
bool atc_compress_mf_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
bool atc_compress_mf_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
bool atc_compress_mf_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
bool atc_compress_mf_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
bool atc_compress_mf_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
bool atc_compress_mf_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
bool atc_compress_mf_options_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
bool atc_compress_mf_options_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
bool atc_compress_mf_options_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
bool atc_compress_mf_options_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
bool atc_compress_mf_options_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
bool atc_compress_mf_options_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
bool atc_compress_mf_options_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
bool atc_compress_mf_options_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
bool atc_compress_mf_options_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
bool atc_compress_mf_options_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
atc_results atc_compress_mf_results_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
atc_results atc_compress_mf_results_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
atc_results atc_compress_mf_results_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
atc_results atc_compress_mf_results_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
atc_results atc_compress_mf_results_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
atc_results atc_compress_mf_results_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
atc_results atc_compress_mf_results_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
atc_results atc_compress_mf_results_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
atc_results atc_compress_mf_results_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
atc_results atc_compress_mf_results_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file)); });
}
atc_results atc_compress_mf_results_options_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
atc_results atc_compress_mf_results_options_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
atc_results atc_compress_mf_results_options_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
atc_results atc_compress_mf_results_options_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
atc_results atc_compress_mf_results_options_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
atc_results atc_compress_mf_results_options_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
atc_results atc_compress_mf_results_options_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
atc_results atc_compress_mf_results_options_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
atc_results atc_compress_mf_results_options_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
atc_results atc_compress_mf_results_options_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_options(options)); });
}
atc_results atc_compress_mm_results_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error); });
}
atc_results atc_compress_mm_results_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error); });
}
atc_results atc_compress_mm_results_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error); });
}
atc_results atc_compress_mm_results_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error); });
}
atc_results atc_compress_mm_results_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error); });
}
atc_results atc_compress_mm_results_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error); });
}
atc_results atc_compress_mm_results_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error); });
}
atc_results atc_compress_mm_results_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error); });
}
atc_results atc_compress_mm_results_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error); });
}
atc_results atc_compress_mm_results_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error); });
}
atc_results atc_compress_mm_results_options_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_options(options)); });
}
atc_results atc_compress_mm_results_options_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_options(options)); });
}
atc_results atc_compress_mm_results_options_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_options(options)); });
}
atc_results atc_compress_mm_results_options_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_options(options)); });
}
atc_results atc_compress_mm_results_options_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_options(options)); });
}
atc_results atc_compress_mm_results_options_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_options(options)); });
}
atc_results atc_compress_mm_results_options_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_options(options)); });
}
atc_results atc_compress_mm_results_options_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_options(options)); });
}
atc_results atc_compress_mm_results_options_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_options(options)); });
}
atc_results atc_compress_mm_results_options_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress(original_data, convert_sizes(modes, sizes), target_error, convert_options(options)); });
}

bool atc_decompress_ff(const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), convert_string(decompressed_file)); });
}
bool atc_decompress_ff_options(const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_decompress_ff_results(const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), convert_string(decompressed_file)); });
}
atc_results atc_decompress_ff_results_options(const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
bool atc_decompress_fm_uint8(const char* compressed_file, size_t decompressed_size, uint8_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
bool atc_decompress_fm_uint16(const char* compressed_file, size_t decompressed_size, uint16_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
bool atc_decompress_fm_uint32(const char* compressed_file, size_t decompressed_size, uint32_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
bool atc_decompress_fm_uint64(const char* compressed_file, size_t decompressed_size, uint64_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
bool atc_decompress_fm_int8(const char* compressed_file, size_t decompressed_size, int8_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
bool atc_decompress_fm_int16(const char* compressed_file, size_t decompressed_size, int16_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
bool atc_decompress_fm_int32(const char* compressed_file, size_t decompressed_size, int32_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
bool atc_decompress_fm_int64(const char* compressed_file, size_t decompressed_size, int64_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
bool atc_decompress_fm_float32(const char* compressed_file, size_t decompressed_size, float* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
bool atc_decompress_fm_float64(const char* compressed_file, size_t decompressed_size, double* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
bool atc_decompress_fm_options_uint8(const char* compressed_file, size_t decompressed_size, uint8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_fm_options_uint16(const char* compressed_file, size_t decompressed_size, uint16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_fm_options_uint32(const char* compressed_file, size_t decompressed_size, uint32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_fm_options_uint64(const char* compressed_file, size_t decompressed_size, uint64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_fm_options_int8(const char* compressed_file, size_t decompressed_size, int8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_fm_options_int16(const char* compressed_file, size_t decompressed_size, int16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_fm_options_int32(const char* compressed_file, size_t decompressed_size, int32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_fm_options_int64(const char* compressed_file, size_t decompressed_size, int64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_fm_options_float32(const char* compressed_file, size_t decompressed_size, float* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_fm_options_float64(const char* compressed_file, size_t decompressed_size, double* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_fm_results_uint8(const char* compressed_file, size_t decompressed_size, uint8_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
atc_results atc_decompress_fm_results_uint16(const char* compressed_file, size_t decompressed_size, uint16_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
atc_results atc_decompress_fm_results_uint32(const char* compressed_file, size_t decompressed_size, uint32_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
atc_results atc_decompress_fm_results_uint64(const char* compressed_file, size_t decompressed_size, uint64_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
atc_results atc_decompress_fm_results_int8(const char* compressed_file, size_t decompressed_size, int8_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
atc_results atc_decompress_fm_results_int16(const char* compressed_file, size_t decompressed_size, int16_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
atc_results atc_decompress_fm_results_int32(const char* compressed_file, size_t decompressed_size, int32_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
atc_results atc_decompress_fm_results_int64(const char* compressed_file, size_t decompressed_size, int64_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
atc_results atc_decompress_fm_results_float32(const char* compressed_file, size_t decompressed_size, float* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
atc_results atc_decompress_fm_results_float64(const char* compressed_file, size_t decompressed_size, double* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data); });
}
atc_results atc_decompress_fm_results_options_uint8(const char* compressed_file, size_t decompressed_size, uint8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_fm_results_options_uint16(const char* compressed_file, size_t decompressed_size, uint16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_fm_results_options_uint32(const char* compressed_file, size_t decompressed_size, uint32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_fm_results_options_uint64(const char* compressed_file, size_t decompressed_size, uint64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_fm_results_options_int8(const char* compressed_file, size_t decompressed_size, int8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_fm_results_options_int16(const char* compressed_file, size_t decompressed_size, int16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_fm_results_options_int32(const char* compressed_file, size_t decompressed_size, int32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_fm_results_options_int64(const char* compressed_file, size_t decompressed_size, int64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_fm_results_options_float32(const char* compressed_file, size_t decompressed_size, float* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_fm_results_options_float64(const char* compressed_file, size_t decompressed_size, double* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(convert_string(compressed_file), decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_mf(size_t compressed_size, const char* compressed_data, const char* decompressed_file) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, convert_string(decompressed_file)); });
}
bool atc_decompress_mf_options(size_t compressed_size, const char* compressed_data, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_decompress_mf_results(size_t compressed_size, const char* compressed_data, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, convert_string(decompressed_file)); });
}
atc_results atc_decompress_mf_results_options(size_t compressed_size, const char* compressed_data, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, convert_string(decompressed_file), convert_options(options)); });
}
bool atc_decompress_mm_uint8(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint8_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
bool atc_decompress_mm_uint16(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint16_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
bool atc_decompress_mm_uint32(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint32_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
bool atc_decompress_mm_uint64(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint64_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
bool atc_decompress_mm_int8(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int8_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
bool atc_decompress_mm_int16(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int16_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
bool atc_decompress_mm_int32(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int32_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
bool atc_decompress_mm_int64(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int64_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
bool atc_decompress_mm_float32(size_t compressed_size, const char* compressed_data, size_t decompressed_size, float* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
bool atc_decompress_mm_float64(size_t compressed_size, const char* compressed_data, size_t decompressed_size, double* decompressed_data) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
bool atc_decompress_mm_options_uint8(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_mm_options_uint16(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_mm_options_uint32(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_mm_options_uint64(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_mm_options_int8(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_mm_options_int16(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_mm_options_int32(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_mm_options_int64(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_mm_options_float32(size_t compressed_size, const char* compressed_data, size_t decompressed_size, float* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
bool atc_decompress_mm_options_float64(size_t compressed_size, const char* compressed_data, size_t decompressed_size, double* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_mm_results_uint8(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint8_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
atc_results atc_decompress_mm_results_uint16(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint16_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
atc_results atc_decompress_mm_results_uint32(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint32_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
atc_results atc_decompress_mm_results_uint64(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint64_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
atc_results atc_decompress_mm_results_int8(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int8_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
atc_results atc_decompress_mm_results_int16(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int16_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
atc_results atc_decompress_mm_results_int32(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int32_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
atc_results atc_decompress_mm_results_int64(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int64_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
atc_results atc_decompress_mm_results_float32(size_t compressed_size, const char* compressed_data, size_t decompressed_size, float* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
atc_results atc_decompress_mm_results_float64(size_t compressed_size, const char* compressed_data, size_t decompressed_size, double* decompressed_data) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data); });
}
atc_results atc_decompress_mm_results_options_uint8(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_mm_results_options_uint16(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_mm_results_options_uint32(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_mm_results_options_uint64(size_t compressed_size, const char* compressed_data, size_t decompressed_size, uint64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_mm_results_options_int8(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_mm_results_options_int16(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_mm_results_options_int32(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_mm_results_options_int64(size_t compressed_size, const char* compressed_data, size_t decompressed_size, int64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_mm_results_options_float32(size_t compressed_size, const char* compressed_data, size_t decompressed_size, float* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}
atc_results atc_decompress_mm_results_options_float64(size_t compressed_size, const char* compressed_data, size_t decompressed_size, double* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::decompress(compressed_size, compressed_data, decompressed_size, decompressed_data, convert_options(options)); });
}

bool atc_compress_decompress_fff(const char* original_file, atc_data_type data_type, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_data_type(data_type), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
bool atc_compress_decompress_fff_options(const char* original_file, atc_data_type data_type, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_data_type(data_type), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_fff_results(const char* original_file, atc_data_type data_type, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_data_type(data_type), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_fff_results_options(const char* original_file, atc_data_type data_type, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_data_type(data_type), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
bool atc_compress_decompress_ffm_uint8(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint8_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_ffm_uint16(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint16_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_ffm_uint32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint32_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_ffm_uint64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint64_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_ffm_int8(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int8_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_ffm_int16(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int16_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_ffm_int32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int32_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_ffm_int64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int64_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_ffm_float32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, float* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_ffm_float64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, double* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_ffm_options_uint8(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_ffm_options_uint16(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_ffm_options_uint32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_ffm_options_uint64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_ffm_options_int8(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_ffm_options_int16(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_ffm_options_int32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_ffm_options_int64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_ffm_options_float32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, float* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_ffm_options_float64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, double* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_ffm_results_uint8(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint8_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_ffm_results_uint16(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint16_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_ffm_results_uint32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint32_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_ffm_results_uint64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint64_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_ffm_results_int8(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int8_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_ffm_results_int16(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int16_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_ffm_results_int32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int32_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_ffm_results_int64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int64_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_ffm_results_float32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, float* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_ffm_results_float64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, double* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_ffm_results_options_uint8(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_ffm_results_options_uint16(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_ffm_results_options_uint32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_ffm_results_options_uint64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_ffm_results_options_int8(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_ffm_results_options_int16(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_ffm_results_options_int32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_ffm_results_options_int64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_ffm_results_options_float32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, float* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_ffm_results_options_float64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, double* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_fmf_results(const char* original_file, atc_data_type data_type, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_data_type(data_type), convert_sizes(modes, sizes), target_error, convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_fmf_results_options(const char* original_file, atc_data_type data_type, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_data_type(data_type), convert_sizes(modes, sizes), target_error, convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_fmm_results_uint8(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, uint8_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_fmm_results_uint16(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, uint16_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_fmm_results_uint32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, uint32_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_fmm_results_uint64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, uint64_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_fmm_results_int8(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, int8_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_fmm_results_int16(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, int16_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_fmm_results_int32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, int32_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_fmm_results_int64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, int64_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_fmm_results_float32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, float* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_fmm_results_float64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, double* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_fmm_results_options_uint8(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, uint8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_fmm_results_options_uint16(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, uint16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_fmm_results_options_uint32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, uint32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_fmm_results_options_uint64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, uint64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_fmm_results_options_int8(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, int8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_fmm_results_options_int16(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, int16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_fmm_results_options_int32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, int32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_fmm_results_options_int64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, int64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_fmm_results_options_float32(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, float* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_fmm_results_options_float64(const char* original_file, uint8_t modes, const size_t* sizes, double target_error, double* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(convert_string(original_file), convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_mff_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
bool atc_compress_decompress_mff_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
bool atc_compress_decompress_mff_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
bool atc_compress_decompress_mff_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
bool atc_compress_decompress_mff_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
bool atc_compress_decompress_mff_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
bool atc_compress_decompress_mff_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
bool atc_compress_decompress_mff_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
bool atc_compress_decompress_mff_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
bool atc_compress_decompress_mff_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
bool atc_compress_decompress_mff_options_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
bool atc_compress_decompress_mff_options_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
bool atc_compress_decompress_mff_options_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
bool atc_compress_decompress_mff_options_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
bool atc_compress_decompress_mff_options_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
bool atc_compress_decompress_mff_options_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
bool atc_compress_decompress_mff_options_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
bool atc_compress_decompress_mff_options_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
bool atc_compress_decompress_mff_options_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
bool atc_compress_decompress_mff_options_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mff_results_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mff_results_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mff_results_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mff_results_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mff_results_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mff_results_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mff_results_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mff_results_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mff_results_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mff_results_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mff_results_options_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mff_results_options_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mff_results_options_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mff_results_options_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mff_results_options_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mff_results_options_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mff_results_options_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mff_results_options_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mff_results_options_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mff_results_options_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), convert_string(decompressed_file), convert_options(options)); });
}
bool atc_compress_decompress_mfm_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint8_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_mfm_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint16_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_mfm_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint32_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_mfm_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint64_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_mfm_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int8_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_mfm_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int16_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_mfm_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int32_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_mfm_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int64_t* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_mfm_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, float* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_mfm_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, double* decompressed_data) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
bool atc_compress_decompress_mfm_options_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_mfm_options_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_mfm_options_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_mfm_options_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_mfm_options_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_mfm_options_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_mfm_options_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_mfm_options_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_mfm_options_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, float* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
bool atc_compress_decompress_mfm_options_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, double* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mfm_results_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint8_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_mfm_results_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint16_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_mfm_results_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint32_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_mfm_results_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint64_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_mfm_results_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int8_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_mfm_results_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int16_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_mfm_results_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int32_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_mfm_results_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int64_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_mfm_results_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, float* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_mfm_results_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, double* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data); });
}
atc_results atc_compress_decompress_mfm_results_options_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mfm_results_options_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mfm_results_options_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mfm_results_options_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, uint64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mfm_results_options_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mfm_results_options_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mfm_results_options_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mfm_results_options_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, int64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mfm_results_options_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, float* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mfm_results_options_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* compressed_file, double* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(compressed_file), decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mmf_results_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mmf_results_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mmf_results_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mmf_results_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mmf_results_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mmf_results_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mmf_results_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mmf_results_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mmf_results_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mmf_results_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file)); });
}
atc_results atc_compress_decompress_mmf_results_options_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mmf_results_options_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mmf_results_options_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mmf_results_options_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mmf_results_options_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mmf_results_options_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mmf_results_options_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mmf_results_options_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mmf_results_options_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mmf_results_options_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, const char* decompressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, convert_string(decompressed_file), convert_options(options)); });
}
atc_results atc_compress_decompress_mmm_results_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, uint8_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_mmm_results_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, uint16_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_mmm_results_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, uint32_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_mmm_results_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, uint64_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_mmm_results_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, int8_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_mmm_results_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, int16_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_mmm_results_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, int32_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_mmm_results_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, int64_t* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_mmm_results_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, float* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_mmm_results_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, double* decompressed_data) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data); });
}
atc_results atc_compress_decompress_mmm_results_options_uint8(const uint8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, uint8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mmm_results_options_uint16(const uint16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, uint16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mmm_results_options_uint32(const uint32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, uint32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mmm_results_options_uint64(const uint64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, uint64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mmm_results_options_int8(const int8_t* original_data, uint8_t modes, const size_t* sizes, double target_error, int8_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mmm_results_options_int16(const int16_t* original_data, uint8_t modes, const size_t* sizes, double target_error, int16_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mmm_results_options_int32(const int32_t* original_data, uint8_t modes, const size_t* sizes, double target_error, int32_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mmm_results_options_int64(const int64_t* original_data, uint8_t modes, const size_t* sizes, double target_error, int64_t* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mmm_results_options_float32(const float* original_data, uint8_t modes, const size_t* sizes, double target_error, float* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}
atc_results atc_compress_decompress_mmm_results_options_float64(const double* original_data, uint8_t modes, const size_t* sizes, double target_error, double* decompressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::compress_decompress(original_data, convert_sizes(modes, sizes), target_error, decompressed_data, convert_options(options)); });
}

atc_data_type atc_read_data_type_f(const char* compressed_file) {
	return wrap_evaluation([&] () { return atc::read_data_type(convert_string(compressed_file)); });
}
atc_data_type atc_read_data_type_m(size_t compressed_size, const char* compressed_data) {
	return wrap_evaluation([&] () { return atc::read_data_type(compressed_size, compressed_data); });
}

size_t atc_read_decompressed_size_f(const char* compressed_file) {
	return wrap_evaluation([&] () { return atc::read_decompressed_size(convert_string(compressed_file)); });
}
size_t atc_read_decompressed_size_f_options(const char* compressed_file, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::read_decompressed_size(convert_string(compressed_file), convert_options(options)); });
}
size_t atc_read_decompressed_size_m(size_t compressed_size, const char* compressed_data) {
	return wrap_evaluation([&] () { return atc::read_decompressed_size(compressed_size, compressed_data); });
}
size_t atc_read_decompressed_size_m_options(size_t compressed_size, const char* compressed_data, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::read_decompressed_size(compressed_size, compressed_data, convert_options(options)); });
}

size_t atc_calculate_decompressed_size(uint8_t modes, const size_t* sizes) {
	return wrap_evaluation([&] () { return atc::calculate_decompressed_size(convert_sizes(modes, sizes)); });
}
size_t atc_calculate_decompressed_size_options(uint8_t modes, const size_t* sizes, const atc_options* options) {
	return wrap_evaluation([&] () { return atc::calculate_decompressed_size(convert_sizes(modes, sizes), convert_options(options)); });
}

