unescape(raw_json_string in, bool allow_replacement) noexcept;\n simdjson_inline simdjson_result<std::string_view> unescape_wobbly(raw_json_string in) noexcept;\n\n simdjson_inline void reenter_child(token_position position, depth_t child_depth) noexcept;\n\n simdjson_warn_unused simdjson_inline error_code consume_character(char c) noexcept;\n#if SIMDJSON_DEVELOPMENT_CHECKS\n simdjson_inline token_position start_position(depth_t depth) const noexcept;\n simdjson_inline void set_start_position(depth_t depth, token_position position) noexcept;\n#endif\n\n /* Useful for debugging and logging purposes. */\n inline std::string to_string() const noexcept;\n\n /**\n * Returns the current location in the document if in bounds.\n */\n inline simdjson_result<const char *> current_location() const noexcept;\n\n /**\n * Updates this json iterator so that it is back at the beginning of the document,\n * as if it had just been created.\n */\n inline void rewind() noexcept;\n /**\n * This checks whether the {,},[,] are balanced so that the document\n * ends with proper zero depth. This requires scanning the whole document\n * and it may be expensive. It is expected that it will be rarely called.\n * It does not attempt to match { with } and [ with ].\n */\n inline bool balanced() const noexcept;\nprotected:\n simdjson_inline json_iterator(const uint8_t *buf, ondemand::parser *parser) noexcept;\n#ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON\n simdjson_inline json_iterator(const uint8_t *buf, ondemand::parser *parser, bool streaming) noexcept;\n#endif // SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON\n /// The last token before the end\n simdjson_inline token_position last_position() const noexcept;\n /// The token *at* the end. This points at gibberish and should only be used for comparison.\n simdjson_inline token_position end_position() const noexcept;\n /// The end of the buffer.\n simdjson_inline token_position end() const noexcept;\n\n friend class document;\n friend class document_stream;\n friend class object;\n friend class array;\n friend class value;\n friend class raw_json_string;\n friend class parser;\n friend class value_iterator;\n friend class field;\n template <typename... Args>\n friend simdjson_inline void logger::log_line(const json_iterator &iter, const char *title_prefix, const char *title, std::string_view detail, int delta, int depth_delta, logger::log_level level, Args&&... args) noexcept;\n template <typename... Args>\n friend simdjson_inline void logger::log_line(const json_iterator &iter, token_position index, depth_t depth, const char *title_prefix, const char *title, std::string_view detail, logger::log_level level, Args&&... args) noexcept;\n}; // json_iterator\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\ntemplate<>\nstruct simdjson_result<lasx::ondemand::json_iterator> : public lasx::implementation_simdjson_result_base<lasx::ondemand::json_iterator> {\npublic:\n simdjson_inline simdjson_result(lasx::ondemand::json_iterator &&value) noexcept; ///< @private\n simdjson_inline simdjson_result(error_code error) noexcept; ///< @private\n\n simdjson_inline simdjson_result() noexcept = default;\n};\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_JSON_ITERATOR_H\n/* end file simdjson/generic/ondemand/json_iterator.h for lasx */\n/* including simdjson/generic/ondemand/json_type.h for lasx: #include \"simdjson/generic/ondemand/json_type.h\" */\n/* begin file simdjson/generic/ondemand/json_type.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_JSON_TYPE_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_JSON_TYPE_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/numberparsing.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\n/**\n * The type of a JSON value.\n */\nenum class json_type {\n unknown=0,\n // Start at 1 to catch uninitialized / default values more easily\n array=1, ///< A JSON array ( [ 1, 2, 3 ... ] )\n object, ///< A JSON object ( { \"a\": 1, \"b\" 2, ... } )\n number, ///< A JSON number ( 1 or -2.3 or 4.5e6 ...)\n string, ///< A JSON string ( \"a\" or \"hello world\\n\" ...)\n boolean, ///< A JSON boolean (true or false)\n null ///< A JSON null (null)\n};\n\n/**\n * A type representing a JSON number.\n * The design of the struct is deliberately straight-forward. All\n * functions return standard values with no error check.\n */\nstruct number {\n\n /**\n * return the automatically determined type of\n * the number: number_type::floating_point_number,\n * number_type::signed_integer or number_type::unsigned_integer.\n *\n * enum class number_type {\n * floating_point_number=1, /// a binary64 number\n * signed_integer, /// a signed integer that fits in a 64-bit word using two's complement\n * unsigned_integer /// a positive integer larger or equal to 1<<63\n * };\n */\n simdjson_inline ondemand::number_type get_number_type() const noexcept;\n /**\n * return true if the automatically determined type of\n * the number is number_type::unsigned_integer.\n */\n simdjson_inline bool is_uint64() const noexcept;\n /**\n * return the value as a uint64_t, only valid if is_uint64() is true.\n */\n simdjson_inline uint64_t get_uint64() const noexcept;\n simdjson_inline operator uint64_t() const noexcept;\n\n /**\n * return true if the automatically determined type of\n * the number is number_type::signed_integer.\n */\n simdjson_inline bool is_int64() const noexcept;\n /**\n * return the value as a int64_t, only valid if is_int64() is true.\n */\n simdjson_inline int64_t get_int64() const noexcept;\n simdjson_inline operator int64_t() const noexcept;\n\n\n /**\n * return true if the automatically determined type of\n * the number is number_type::floating_point_number.\n */\n simdjson_inline bool is_double() const noexcept;\n /**\n * return the value as a double, only valid if is_double() is true.\n */\n simdjson_inline double get_double() const noexcept;\n simdjson_inline operator double() const noexcept;\n\n /**\n * Convert the number to a double. Though it always succeed, the conversion\n * may be lossy if the number cannot be represented exactly.\n */\n simdjson_inline double as_double() const noexcept;\n\n\nprotected:\n /**\n * The next block of declaration is designed so that we can call the number parsing\n * functions on a number type. They are protected and should never be used outside\n * of the core simdjson library.\n */\n friend class value_iterator;\n template<typename W>\n friend error_code numberparsing::write_float(const uint8_t *const src, bool negative, uint64_t i, const uint8_t * start_digits, size_t digit_count, int64_t exponent, W &writer);\n template<typename W>\n friend error_code numberparsing::parse_number(const uint8_t *const src, W &writer);\n /** Store a signed 64-bit value to the number. */\n simdjson_inline void append_s64(int64_t value) noexcept;\n /** Store an unsigned 64-bit value to the number. */\n simdjson_inline void append_u64(uint64_t value) noexcept;\n /** Store a double value to the number. */\n simdjson_inline void append_double(double value) noexcept;\n /** Specifies that the value is a double, but leave it undefined. */\n simdjson_inline void skip_double() noexcept;\n /**\n * End of friend declarations.\n */\n\n /**\n * Our attributes are a union type (size = 64 bits)\n * followed by a type indicator.\n */\n union {\n double floating_point_number;\n int64_t signed_integer;\n uint64_t unsigned_integer;\n } payload{0};\n number_type type{number_type::signed_integer};\n};\n\n/**\n * Write the JSON type to the output stream\n *\n * @param out The output stream.\n * @param type The json_type.\n */\ninline std::ostream& operator<<(std::ostream& out, json_type type) noexcept;\n\n#if SIMDJSON_EXCEPTIONS\n/**\n * Send JSON type to an output stream.\n *\n * @param out The output stream.\n * @param type The json_type.\n * @throw simdjson_error if the result being printed has an error. If there is an error with the\n * underlying output stream, that error will be propagated (simdjson_error will not be\n * thrown).\n */\ninline std::ostream& operator<<(std::ostream& out, simdjson_result<json_type> &type) noexcept(false);\n#endif\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\ntemplate<>\nstruct simdjson_result<lasx::ondemand::json_type> : public lasx::implementation_simdjson_result_base<lasx::ondemand::json_type> {\npublic:\n simdjson_inline simdjson_result(lasx::ondemand::json_type &&value) noexcept; ///< @private\n simdjson_inline simdjson_result(error_code error) noexcept; ///< @private\n simdjson_inline simdjson_result() noexcept = default;\n simdjson_inline ~simdjson_result() noexcept = default; ///< @private\n};\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_JSON_TYPE_H\n/* end file simdjson/generic/ondemand/json_type.h for lasx */\n/* including simdjson/generic/ondemand/raw_json_string.h for lasx: #include \"simdjson/generic/ondemand/raw_json_string.h\" */\n/* begin file simdjson/generic/ondemand/raw_json_string.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\n/**\n * A string escaped per JSON rules, terminated with quote (\"). They are used to represent\n * unescaped keys inside JSON documents.\n *\n * (In other words, a pointer to the beginning of a string, just after the start quote, inside a\n * JSON file.)\n *\n * This class is deliberately simplistic and has little functionality. You can\n * compare a raw_json_string instance with an unescaped C string, but\n * that is nearly all you can do.\n *\n * The raw_json_string is unescaped. If you wish to write an unescaped version of it to your own\n * buffer, you may do so using the parser.unescape(string, buff) method, using an ondemand::parser\n * instance. Doing so requires you to have a sufficiently large buffer.\n *\n * The raw_json_string instances originate typically from field instance which in turn represent\n * key-value pairs from object instances. From a field instance, you get the raw_json_string\n * instance by calling key(). You can, if you want a more usable string_view instance, call\n * the unescaped_key() method on the field instance. You may also create a raw_json_string from\n * any other string value, with the value.get_raw_json_string() method. Again, you can get\n * a more usable string_view instance by calling get_string().\n *\n */\nclass raw_json_string {\npublic:\n /**\n * Create a new invalid raw_json_string.\n *\n * Exists so you can declare a variable and later assign to it before use.\n */\n simdjson_inline raw_json_string() noexcept = default;\n\n /**\n * Create a new invalid raw_json_string pointed at the given location in the JSON.\n *\n * The given location must be just *after* the beginning quote (\") in the JSON file.\n *\n * It *must* be terminated by a \", and be a valid JSON string.\n */\n simdjson_inline raw_json_string(const uint8_t * _buf) noexcept;\n /**\n * Get the raw pointer to the beginning of the string in the JSON (just after the \").\n *\n * It is possible for this function to return a null pointer if the instance\n * has outlived its existence.\n */\n simdjson_inline const char * raw() const noexcept;\n\n /**\n * Get the character at index i. This is unchecked.\n * [0] when the string is of length 0 returns the final quote (\").\n */\n simdjson_inline char operator[](size_t i) const noexcept;\n\n /**\n * This compares the current instance to the std::string_view target: returns true if\n * they are byte-by-byte equal (no escaping is done) on target.size() characters,\n * and if the raw_json_string instance has a quote character at byte index target.size().\n * We never read more than length + 1 bytes in the raw_json_string instance.\n * If length is smaller than target.size(), this will return false.\n *\n * The std::string_view instance may contain any characters. However, the caller\n * is responsible for setting length so that length bytes may be read in the\n * raw_json_string.\n *\n * Performance: the comparison may be done using memcmp which may be efficient\n * for long strings.\n */\n simdjson_inline bool unsafe_is_equal(size_t length, std::string_view target) const noexcept;\n\n /**\n * This compares the current instance to the std::string_view target: returns true if\n * they are byte-by-byte equal (no escaping is done).\n * The std::string_view instance should not contain unescaped quote characters:\n * the caller is responsible for this check. See is_free_from_unescaped_quote.\n *\n * Performance: the comparison is done byte-by-byte which might be inefficient for\n * long strings.\n *\n * If target is a compile-time constant, and your compiler likes you,\n * you should be able to do the following without performance penalty...\n *\n * static_assert(raw_json_string::is_free_from_unescaped_quote(target), \"\");\n * s.unsafe_is_equal(target);\n */\n simdjson_inline bool unsafe_is_equal(std::string_view target) const noexcept;\n\n /**\n * This compares the current instance to the C string target: returns true if\n * they are byte-by-byte equal (no escaping is done).\n * The provided C string should not contain an unescaped quote character:\n * the caller is responsible for this check. See is_free_from_unescaped_quote.\n *\n * If target is a compile-time constant, and your compiler likes you,\n * you should be able to do the following without performance penalty...\n *\n * static_assert(raw_json_string::is_free_from_unescaped_quote(target), \"\");\n * s.unsafe_is_equal(target);\n */\n simdjson_inline bool unsafe_is_equal(const char* target) const noexcept;\n\n /**\n * This compares the current instance to the std::string_view target: returns true if\n * they are byte-by-byte equal (no escaping is done).\n */\n simdjson_inline bool is_equal(std::string_view target) const noexcept;\n\n /**\n * This compares the current instance to the C string target: returns true if\n * they are byte-by-byte equal (no escaping is done).\n */\n simdjson_inline bool is_equal(const char* target) const noexcept;\n\n /**\n * Returns true if target is free from unescaped quote. If target is known at\n * compile-time, we might expect the computation to happen at compile time with\n * many compilers (not all!).\n */\n static simdjson_inline bool is_free_from_unescaped_quote(std::string_view target) noexcept;\n static simdjson_inline bool is_free_from_unescaped_quote(const char* target) noexcept;\n\nprivate:\n\n\n /**\n * This will set the inner pointer to zero, effectively making\n * this instance unusable.\n */\n simdjson_inline void consume() noexcept { buf = nullptr; }\n\n /**\n * Checks whether the inner pointer is non-null and thus usable.\n */\n simdjson_inline simdjson_warn_unused bool alive() const noexcept { return buf != nullptr; }\n\n /**\n * Unescape this JSON string, replacing \\\\ with \\, \\n with newline, etc.\n * The result will be a valid UTF-8.\n *\n * ## IMPORTANT: string_view lifetime\n *\n * The string_view is only valid until the next parse() call on the parser.\n *\n * @param iter A json_iterator, which contains a buffer where the string will be written.\n * @param allow_replacement Whether we allow replacement of invalid surrogate pairs.\n */\n simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> unescape(json_iterator &iter, bool allow_replacement) const noexcept;\n\n /**\n * Unescape this JSON string, replacing \\\\ with \\, \\n with newline, etc.\n * The result may not be a valid UTF-8. https://simonsapin.github.io/wtf-8/\n *\n * ## IMPORTANT: string_view lifetime\n *\n * The string_view is only valid until the next parse() call on the parser.\n *\n * @param iter A json_iterator, which contains a buffer where the string will be written.\n */\n simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> unescape_wobbly(json_iterator &iter) const noexcept;\n const uint8_t * buf{};\n friend class object;\n friend class field;\n friend class parser;\n friend struct simdjson_result<raw_json_string>;\n};\n\nsimdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &, const raw_json_string &) noexcept;\n\n/**\n * Comparisons between raw_json_string and std::string_view instances are potentially unsafe: the user is responsible\n * for providing a string with no unescaped quote. Note that unescaped quotes cannot be present in valid JSON strings.\n */\nsimdjson_unused simdjson_inline bool operator==(const raw_json_string &a, std::string_view c) noexcept;\nsimdjson_unused simdjson_inline bool operator==(std::string_view c, const raw_json_string &a) noexcept;\nsimdjson_unused simdjson_inline bool operator!=(const raw_json_string &a, std::string_view c) noexcept;\nsimdjson_unused simdjson_inline bool operator!=(std::string_view c, const raw_json_string &a) noexcept;\n\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\ntemplate<>\nstruct simdjson_result<lasx::ondemand::raw_json_string> : public lasx::implementation_simdjson_result_base<lasx::ondemand::raw_json_string> {\npublic:\n simdjson_inline simdjson_result(lasx::ondemand::raw_json_string &&value) noexcept; ///< @private\n simdjson_inline simdjson_result(error_code error) noexcept; ///< @private\n simdjson_inline simdjson_result() noexcept = default;\n simdjson_inline ~simdjson_result() noexcept = default; ///< @private\n\n simdjson_inline simdjson_result<const char *> raw() const noexcept;\n simdjson_inline char operator[](size_t) const noexcept;\n simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> unescape(lasx::ondemand::json_iterator &iter, bool allow_replacement) const noexcept;\n simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> unescape_wobbly(lasx::ondemand::json_iterator &iter) const noexcept;\n};\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_H\n/* end file simdjson/generic/ondemand/raw_json_string.h for lasx */\n/* including simdjson/generic/ondemand/parser.h for lasx: #include \"simdjson/generic/ondemand/parser.h\" */\n/* begin file simdjson/generic/ondemand/parser.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_PARSER_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_PARSER_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\n#include <memory>\n#include <thread>\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\n/**\n * The default batch size for document_stream instances for this On-Demand kernel.\n * Note that different On-Demand kernel may use a different DEFAULT_BATCH_SIZE value\n * in the future.\n */\nstatic constexpr size_t DEFAULT_BATCH_SIZE = 1000000;\n/**\n * Some adversary might try to set the batch size to 0 or 1, which might cause problems.\n * We set a minimum of 32B since anything else is highly likely to be an error. In practice,\n * most users will want a much larger batch size.\n *\n * All non-negative MINIMAL_BATCH_SIZE values should be 'safe' except that, obviously, no JSON\n * document can ever span 0 or 1 byte and that very large values would create memory allocation issues.\n */\nstatic constexpr size_t MINIMAL_BATCH_SIZE = 32;\n\n/**\n * A JSON fragment iterator.\n *\n * This holds the actual iterator as well as the buffer for writing strings.\n */\nclass parser {\npublic:\n /**\n * Create a JSON parser.\n *\n * The new parser will have zero capacity.\n */\n inline explicit parser(size_t max_capacity = SIMDJSON_MAXSIZE_BYTES) noexcept;\n\n inline parser(parser &&other) noexcept = default;\n simdjson_inline parser(const parser &other) = delete;\n simdjson_inline parser &operator=(const parser &other) = delete;\n simdjson_inline parser &operator=(parser &&other) noexcept = default;\n\n /** Deallocate the JSON parser. */\n inline ~parser() noexcept = default;\n\n /**\n * Start iterating an on-demand JSON document.\n *\n * ondemand::parser parser;\n * document doc = parser.iterate(json);\n *\n * It is expected that the content is a valid UTF-8 file, containing a valid JSON document.\n * Otherwise the iterate method may return an error. In particular, the whole input should be\n * valid: we do not attempt to tolerate incorrect content either before or after a JSON\n * document. If there is a UTF-8 BOM, the parser skips it.\n *\n * ### IMPORTANT: Validate what you use\n *\n * Calling iterate on an invalid JSON document may not immediately trigger an error. The call to\n * iterate does not parse and validate the whole document.\n *\n * ### IMPORTANT: Buffer Lifetime\n *\n * Because parsing is done while you iterate, you *must* keep the JSON buffer around at least as\n * long as the document iteration.\n *\n * ### IMPORTANT: Document Lifetime\n *\n * Only one iteration at a time can happen per parser, and the parser *must* be kept alive during\n * iteration to ensure intermediate buffers can be accessed. Any document must be destroyed before\n * you call parse() again or destroy the parser.\n *\n * ### REQUIRED: Buffer Padding\n *\n * The buffer must have at least SIMDJSON_PADDING extra allocated bytes. It does not matter what\n * those bytes are initialized to, as long as they are allocated. These bytes will be read: if you\n * using a sanitizer that verifies that no uninitialized byte is read, then you should initialize the\n * SIMDJSON_PADDING bytes to avoid runtime warnings.\n *\n * ### std::string references\n *\n * If you pass a mutable std::string reference (std::string&), the parser will seek to extend\n * its capacity to SIMDJSON_PADDING bytes beyond the end of the string.\n *\n * Whenever you pass an std::string reference, the parser will access the bytes beyond the end of\n * the string but before the end of the allocated memory (std::string::capacity()).\n * If you are using a sanitizer that checks for reading uninitialized bytes or std::string's\n * container-overflow checks, you may encounter sanitizer warnings.\n * You can safely ignore these warnings. Or you can call simdjson::pad(std::string&) to pad the\n * string with SIMDJSON_PADDING spaces: this function returns a simdjson::padding_string_view\n * which can be be passed to the parser's iterate function:\n *\n * std::string json = R\"({ \"foo\": 1 } { \"foo\": 2 } { \"foo\": 3 } )\";\n * document doc = parser.iterate(simdjson::pad(json));\n *\n * @param json The JSON to parse.\n * @param len The length of the JSON.\n * @param capacity The number of bytes allocated in the JSON (must be at least len+SIMDJSON_PADDING).\n *\n * @return The document, or an error:\n * - INSUFFICIENT_PADDING if the input has less than SIMDJSON_PADDING extra bytes.\n * - MEMALLOC if realloc_if_needed the parser does not have enough capacity, and memory\n * allocation fails.\n * - EMPTY if the document is all whitespace.\n * - UTF8_ERROR if the document is not valid UTF-8.\n * - UNESCAPED_CHARS if a string contains control characters that must be escaped\n * - UNCLOSED_STRING if there is an unclosed string in the document.\n */\n simdjson_warn_unused simdjson_result<document> iterate(padded_string_view json) & noexcept;\n#ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON\n simdjson_warn_unused simdjson_result<document> iterate_allow_incomplete_json(padded_string_view json) & noexcept;\n#endif // SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON\n /** @overload simdjson_result<document> iterate(padded_string_view json) & noexcept */\n simdjson_warn_unused simdjson_result<document> iterate(const char *json, size_t len, size_t capacity) & noexcept;\n /** @overload simdjson_result<document> iterate(padded_string_view json) & noexcept */\n simdjson_warn_unused simdjson_result<document> iterate(const uint8_t *json, size_t len, size_t capacity) & noexcept;\n /** @overload simdjson_result<document> iterate(padded_string_view json) & noexcept */\n simdjson_warn_unused simdjson_result<document> iterate(std::string_view json, size_t capacity) & noexcept;\n /** @overload simdjson_result<document> iterate(padded_string_view json) & noexcept */\n simdjson_warn_unused simdjson_result<document> iterate(const std::string &json) & noexcept;\n /** @overload simdjson_result<document> iterate(padded_string_view json) & noexcept\n The string instance might be have its capacity extended. Note that this can still\n result in AddressSanitizer: container-overflow in some cases. */\n simdjson_warn_unused simdjson_result<document> iterate(std::string &json) & noexcept;\n /** @overload simdjson_result<document> iterate(padded_string_view json) & noexcept */\n simdjson_warn_unused simdjson_result<document> iterate(const simdjson_result<padded_string> &json) & noexcept;\n /** @overload simdjson_result<document> iterate(padded_string_view json) & noexcept */\n simdjson_warn_unused simdjson_result<document> iterate(const simdjson_result<padded_string_view> &json) & noexcept;\n /** @overload simdjson_result<document> iterate(padded_string_view json) & noexcept */\n simdjson_warn_unused simdjson_result<document> iterate(padded_string &&json) & noexcept = delete;\n\n /**\n * @private\n *\n * Start iterating an on-demand JSON document.\n *\n * ondemand::parser parser;\n * json_iterator doc = parser.iterate(json);\n *\n * ### IMPORTANT: Buffer Lifetime\n *\n * Because parsing is done while you iterate, you *must* keep the JSON buffer around at least as\n * long as the document iteration.\n *\n * ### IMPORTANT: Document Lifetime\n *\n * Only one iteration at a time can happen per parser, and the parser *must* be kept alive during\n * iteration to ensure intermediate buffers can be accessed. Any document must be destroyed before\n * you call parse() again or destroy the parser.\n *\n * The ondemand::document instance holds the iterator. The document must remain in scope\n * while you are accessing instances of ondemand::value, ondemand::object, ondemand::array.\n *\n * ### REQUIRED: Buffer Padding\n *\n * The buffer must have at least SIMDJSON_PADDING extra allocated bytes. It does not matter what\n * those bytes are initialized to, as long as they are allocated. These bytes will be read: if you\n * using a sanitizer that verifies that no uninitialized byte is read, then you should initialize the\n * SIMDJSON_PADDING bytes to avoid runtime warnings.\n *\n * @param json The JSON to parse.\n *\n * @return The iterator, or an error:\n * - INSUFFICIENT_PADDING if the input has less than SIMDJSON_PADDING extra bytes.\n * - MEMALLOC if realloc_if_needed the parser does not have enough capacity, and memory\n * allocation fails.\n * - EMPTY if the document is all whitespace.\n * - UTF8_ERROR if the document is not valid UTF-8.\n * - UNESCAPED_CHARS if a string contains control characters that must be escaped\n * - UNCLOSED_STRING if there is an unclosed string in the document.\n */\n simdjson_warn_unused simdjson_result<json_iterator> iterate_raw(padded_string_view json) & noexcept;\n\n\n /**\n * Parse a buffer containing many JSON documents.\n *\n * auto json = R\"({ \"foo\": 1 } { \"foo\": 2 } { \"foo\": 3 } )\"_padded;\n * ondemand::parser parser;\n * ondemand::document_stream docs = parser.iterate_many(json);\n * for (auto & doc : docs) {\n * std::cout << doc[\"foo\"] << std::endl;\n * }\n * // Prints 1 2 3\n *\n * No copy of the input buffer is made.\n *\n * The function is lazy: it may be that no more than one JSON document at a time is parsed.\n *\n * The caller is responsabile to ensure that the input string data remains unchanged and is\n * not deleted during the loop.\n *\n * ### Format\n *\n * The buffer must contain a series of one or more JSON documents, concatenated into a single\n * buffer, separated by ASCII whitespace. It effectively parses until it has a fully valid document,\n * then starts parsing the next document at that point. (It does this with more parallelism and\n * lookahead than you might think, though.)\n *\n * documents that consist of an object or array may omit the whitespace between them, concatenating\n * with no separator. Documents that consist of a single primitive (i.e. documents that are not\n * arrays or objects) MUST be separated with ASCII whitespace.\n *\n * The characters inside a JSON document, and between JSON documents, must be valid Unicode (UTF-8).\n * If there is a UTF-8 BOM, the parser skips it.\n *\n * The documents must not exceed batch_size bytes (by default 1MB) or they will fail to parse.\n * Setting batch_size to excessively large or excessively small values may impact negatively the\n * performance.\n *\n * ### Threads\n *\n * When compiled with SIMDJSON_THREADS_ENABLED, this method will use a single thread under the\n * hood to do some lookahead.\n *\n * ### REQUIRED: Buffer Padding\n *\n * The buffer must have at least SIMDJSON_PADDING extra allocated bytes. It does not matter what\n * those bytes are initialized to, as long as they are allocated. These bytes will be read: if you\n * using a sanitizer that verifies that no uninitialized byte is read, then you should initialize the\n * SIMDJSON_PADDING bytes to avoid runtime warnings.\n *\n * This is checked automatically with all iterate_many function calls, except for the two\n * that take pointers (const char* or const uint8_t*).\n *\n * ### Threads\n *\n * ### Parser Capacity\n *\n * If the parser's current capacity is less than batch_size, it will allocate enough capacity\n * to handle it (up to max_capacity).\n *\n * @param buf The concatenated JSON to parse.\n * @param len The length of the concatenated JSON.\n * @param batch_size The batch size to use. MUST be larger than the largest document. The sweet\n * spot is cache-related: small enough to fit in cache, yet big enough to\n * parse as many documents as possible in one tight loop.\n * Defaults to 10MB, which has been a reasonable sweet spot in our tests.\n * @param allow_comma_separated (defaults on false) This allows a mode where the documents are\n * separated by commas instead of whitespace. It comes with a performance\n * penalty because the entire document is indexed at once (and the document must be\n * less than 4 GB), and there is no multithreading. In this mode, the batch_size parameter\n * is effectively ignored, as it is set to at least the document size.\n * @return The stream, or an error. An empty input will yield 0 documents rather than an EMPTY error. Errors:\n * - MEMALLOC if the parser does not have enough capacity and memory allocation fails\n * - CAPACITY if the parser does not have enough capacity and batch_size > max_capacity.\n * - other json errors if parsing fails. You should not rely on these errors to always the same for the\n * same document: they may vary under runtime dispatch (so they may vary depending on your system and hardware).\n */\n inline simdjson_result<document_stream> iterate_many(const uint8_t *buf, size_t len, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;\n /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size) */\n inline simdjson_result<document_stream> iterate_many(padded_string_view json, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;\n /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size) */\n inline simdjson_result<document_stream> iterate_many(const char *buf, size_t len, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;\n /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size) */\n inline simdjson_result<document_stream> iterate_many(const std::string &s, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;\n /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size)\n the string might be automatically padded with up to SIMDJSON_PADDING whitespace characters */\n inline simdjson_result<document_stream> iterate_many(std::string &s, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;\n /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size) */\n inline simdjson_result<document_stream> iterate_many(const padded_string &s, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;\n /** @private We do not want to allow implicit conversion from C string to std::string. */\n simdjson_result<document_stream> iterate_many(const char *buf, size_t batch_size = DEFAULT_BATCH_SIZE) noexcept = delete;\n\n /** The capacity of this parser (the largest document it can process). */\n simdjson_pure simdjson_inline size_t capacity() const noexcept;\n /** The maximum capacity of this parser (the largest document it is allowed to process). */\n simdjson_pure simdjson_inline size_t max_capacity() const noexcept;\n simdjson_inline void set_max_capacity(size_t max_capacity) noexcept;\n /**\n * The maximum depth of this parser (the most deeply nested objects and arrays it can process).\n * This parameter is only relevant when the macro SIMDJSON_DEVELOPMENT_CHECKS is set to true.\n * The document's instance current_depth() method should be used to monitor the parsing\n * depth and limit it if desired.\n */\n simdjson_pure simdjson_inline size_t max_depth() const noexcept;\n\n /**\n * Ensure this parser has enough memory to process JSON documents up to `capacity` bytes in length\n * and `max_depth` depth.\n *\n * The max_depth parameter is only relevant when the macro SIMDJSON_DEVELOPMENT_CHECKS is set to true.\n * The document's instance current_depth() method should be used to monitor the parsing\n * depth and limit it if desired.\n *\n * @param capacity The new capacity.\n * @param max_depth The new max_depth. Defaults to DEFAULT_MAX_DEPTH.\n * @return The error, if there is one.\n */\n simdjson_warn_unused error_code allocate(size_t capacity, size_t max_depth=DEFAULT_MAX_DEPTH) noexcept;\n\n #ifdef SIMDJSON_THREADS_ENABLED\n /**\n * The parser instance can use threads when they are available to speed up some\n * operations. It is enabled by default. Changing this attribute will change the\n * behavior of the parser for future operations.\n */\n bool threaded{true};\n #else\n /**\n * When SIMDJSON_THREADS_ENABLED is not defined, the parser instance cannot use threads.\n */\n bool threaded{false};\n #endif\n /**\n * Unescape this JSON string, replacing \\\\ with \\, \\n with newline, etc. to a user-provided buffer.\n * The result must be valid UTF-8.\n * The provided pointer is advanced to the end of the string by reference, and a string_view instance\n * is returned. You can ensure that your buffer is large enough by allocating a block of memory at least\n * as large as the input JSON plus SIMDJSON_PADDING and then unescape all strings to this one buffer.\n *\n * This unescape function is a low-level function. If you want a more user-friendly approach, you should\n * avoid raw_json_string instances (e.g., by calling unescaped_key() instead of key() or get_string()\n * instead of get_raw_json_string()).\n *\n * ## IMPORTANT: string_view lifetime\n *\n * The string_view is only valid as long as the bytes in dst.\n *\n * @param raw_json_string input\n * @param dst A pointer to a buffer at least large enough to write this string as well as\n * an additional SIMDJSON_PADDING bytes.\n * @param allow_replacement Whether we allow a replacement if the input string contains unmatched surrogate pairs.\n * @return A string_view pointing at the unescaped string in dst\n * @error STRING_ERROR if escapes are incorrect.\n */\n simdjson_inline simdjson_result<std::string_view> unescape(raw_json_string in, uint8_t *&dst, bool allow_replacement = false) const noexcept;\n\n /**\n * Unescape this JSON string, replacing \\\\ with \\, \\n with newline, etc. to a user-provided buffer.\n * The result may not be valid UTF-8. See https://simonsapin.github.io/wtf-8/\n * The provided pointer is advanced to the end of the string by reference, and a string_view instance\n * is returned. You can ensure that your buffer is large enough by allocating a block of memory at least\n * as large as the input JSON plus SIMDJSON_PADDING and then unescape all strings to this one buffer.\n *\n * This unescape function is a low-level function. If you want a more user-friendly approach, you should\n * avoid raw_json_string instances (e.g., by calling unescaped_key() instead of key() or get_string()\n * instead of get_raw_json_string()).\n *\n * ## IMPORTANT: string_view lifetime\n *\n * The string_view is only valid as long as the bytes in dst.\n *\n * @param raw_json_string input\n * @param dst A pointer to a buffer at least large enough to write this string as well as\n * an additional SIMDJSON_PADDING bytes.\n * @return A string_view pointing at the unescaped string in dst\n * @error STRING_ERROR if escapes are incorrect.\n */\n simdjson_inline simdjson_result<std::string_view> unescape_wobbly(raw_json_string in, uint8_t *&dst) const noexcept;\n\n#if SIMDJSON_DEVELOPMENT_CHECKS\n /**\n * Returns true if string_buf_loc is outside of the allocated range for the\n * the string buffer. When true, it indicates that the string buffer has overflowed.\n * This is a development-time check that is not needed in production. It can be\n * used to detect buffer overflows in the string buffer and usafe usage of the\n * string buffer.\n */\n bool string_buffer_overflow(const uint8_t *string_buf_loc) const noexcept;\n#endif\n\n /**\n * Get a unique parser instance corresponding to the current thread.\n * This instance can be safely used within the current thread, but it should\n * not be passed to other threads.\n *\n * A parser should only be used for one document at a time.\n *\n * Our simdjson::from functions use this parser instance.\n *\n * You can free the related parser by calling release_parser().\n */\n static simdjson_inline simdjson_warn_unused ondemand::parser& get_parser();\n /**\n * Release the parser instance initialized by get_parser() and all the\n * associated resources (memory). Returns true if a parser instance\n * was released.\n */\n static simdjson_inline bool release_parser();\n\nprivate:\n friend bool release_parser();\n friend ondemand::parser& get_parser();\n /** Get the thread-local parser instance, allocates it if needed */\n static simdjson_inline simdjson_warn_unused std::unique_ptr<ondemand::parser>& get_parser_instance();\n /** Get the thread-local parser instance, it might be null */\n static simdjson_inline simdjson_warn_unused std::unique_ptr<ondemand::parser>& get_threadlocal_parser_if_exists();\n /** @private [for benchmarking access] The implementation to use */\n std::unique_ptr<simdjson::internal::dom_parser_implementation> implementation{};\n size_t _capacity{0};\n size_t _max_capacity;\n size_t _max_depth{DEFAULT_MAX_DEPTH};\n std::unique_ptr<uint8_t[]> string_buf{};\n\n#if SIMDJSON_DEVELOPMENT_CHECKS\n std::unique_ptr<token_position[]> start_positions{};\n#endif\n\n friend class json_iterator;\n friend class document_stream;\n};\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\ntemplate<>\nstruct simdjson_result<lasx::ondemand::parser> : public lasx::implementation_simdjson_result_base<lasx::ondemand::parser> {\npublic:\n simdjson_inline simdjson_result(lasx::ondemand::parser &&value) noexcept; ///< @private\n simdjson_inline simdjson_result(error_code error) noexcept; ///< @private\n simdjson_inline simdjson_result() noexcept = default;\n};\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_PARSER_H\n/* end file simdjson/generic/ondemand/parser.h for lasx */\n\n// JSON builder - needed for extract_into functionality\n/* including simdjson/generic/ondemand/json_string_builder.h for lasx: #include \"simdjson/generic/ondemand/json_string_builder.h\" */\n/* begin file simdjson/generic/ondemand/json_string_builder.h for lasx */\n/**\n * This file is part of the builder API. It is temporarily in the ondemand directory\n * but we will move it to a builder directory later.\n */\n#ifndef SIMDJSON_GENERIC_STRING_BUILDER_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_STRING_BUILDER_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\n\n\n#if SIMDJSON_SUPPORTS_CONCEPTS\n\nnamespace lasx {\nnamespace builder {\n class string_builder;\n}}\n\ntemplate <typename T, typename = void>\nstruct has_custom_serialization : std::false_type {};\n\ninline constexpr struct serialize_tag {\n template <typename T>\n requires custom_deserializable<T>\n constexpr void operator()(lasx::builder::string_builder& b, T& obj) const{\n return tag_invoke(*this, b, obj);\n }\n\n\n} serialize{};\ntemplate <typename T>\nstruct has_custom_serialization<T, std::void_t<\n decltype(tag_invoke(serialize, std::declval<lasx::builder::string_builder&>(), std::declval<T&>()))\n>> : std::true_type {};\n\ntemplate <typename T>\nconstexpr bool require_custom_serialization = has_custom_serialization<T>::value;\n#else\nstruct has_custom_serialization : std::false_type {};\n#endif // SIMDJSON_SUPPORTS_CONCEPTS\n\nnamespace lasx {\nnamespace builder {\n/**\n * A builder for JSON strings representing documents. This is a low-level\n * builder that is not meant to be used directly by end-users. Though it\n * supports atomic types (Booleans, strings), it does not support composed\n * types (arrays and objects).\n *\n * Ultimately, this class can support kernel-specific optimizations. E.g.,\n * it may make use of SIMD instructions to escape strings faster.\n */\nclass string_builder {\npublic:\n simdjson_inline string_builder(size_t initial_capacity = DEFAULT_INITIAL_CAPACITY);\n\n static constexpr size_t DEFAULT_INITIAL_CAPACITY = 1024;\n\n /**\n * Append number (includes Booleans). Booleans are mapped to the strings\n * false and true. Numbers are converted to strings abiding by the JSON standard.\n * Floating-point numbers are converted to the shortest string that 'correctly'\n * represents the number.\n */\n template<typename number_type,\n typename = typename std::enable_if<std::is_arithmetic<number_type>::value>::type>\n simdjson_inline void append(number_type v) noexcept;\n\n /**\n * Append character c.\n */\n simdjson_inline void append(char c) noexcept;\n\n /**\n * Append the string 'null'.\n */\n simdjson_inline void append_null() noexcept;\n\n /**\n * Clear the content.\n */\n simdjson_inline void clear() noexcept;\n\n /**\n * Append the std::string_view, after escaping it.\n * There is no UTF-8 validation.\n */\n simdjson_inline void escape_and_append(std::string_view input) noexcept;\n\n /**\n * Append the std::string_view surrounded by double quotes, after escaping it.\n * There is no UTF-8 validation.\n */\n simdjson_inline void escape_and_append_with_quotes(std::string_view input) noexcept;\n#if SIMDJSON_SUPPORTS_CONCEPTS\n template<constevalutil::fixed_string key>\n simdjson_inline void escape_and_append_with_quotes() noexcept;\n#endif\n /**\n * Append the character surrounded by double quotes, after escaping it.\n * There is no UTF-8 validation.\n */\n simdjson_inline void escape_and_append_with_quotes(char input) noexcept;\n\n /**\n * Append the character surrounded by double quotes, after escaping it.\n * There is no UTF-8 validation.\n */\n simdjson_inline void escape_and_append_with_quotes(const char* input) noexcept;\n\n /**\n * Append the C string directly, without escaping.\n * There is no UTF-8 validation.\n */\n simdjson_inline void append_raw(const char *c) noexcept;\n\n /**\n * Append \"{\" to the buffer.\n */\n simdjson_inline void start_object() noexcept;\n\n /**\n * Append \"}\" to the buffer.\n */\n simdjson_inline void end_object() noexcept;\n\n /**\n * Append \"[\" to the buffer.\n */\n simdjson_inline void start_array() noexcept;\n\n /**\n * Append \"]\" to the buffer.\n */\n simdjson_inline void end_array() noexcept;\n\n /**\n * Append \",\" to the buffer.\n */\n simdjson_inline void append_comma() noexcept;\n\n /**\n * Append \":\" to the buffer.\n */\n simdjson_inline void append_colon() noexcept;\n\n /**\n * Append a key-value pair to the buffer.\n * The key is escaped and surrounded by double quotes.\n * The value is escaped if it is a string.\n */\n template<typename key_type, typename value_type>\n simdjson_inline void append_key_value(key_type key, value_type value) noexcept;\n#if SIMDJSON_SUPPORTS_CONCEPTS\n template<constevalutil::fixed_string key, typename value_type>\n simdjson_inline void append_key_value(value_type value) noexcept;\n\n // Support for optional types (std::optional, etc.)\n template <concepts::optional_type T>\n requires(!require_custom_serialization<T>)\n simdjson_inline void append(const T &opt);\n\n template <typename T>\n requires(require_custom_serialization<T>)\n simdjson_inline void append(const T &val);\n\n // Support for string-like types\n template <typename T>\n requires(std::is_convertible<T, std::string_view>::value ||\n std::is_same<T, const char*>::value )\n simdjson_inline void append(const T &value);\n#endif\n#if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS\n // Support for range-based appending (std::ranges::view, etc.)\n template <std::ranges::range R>\nrequires (!std::is_convertible<R, std::string_view>::value)\n simdjson_inline void append(const R &range) noexcept;\n#endif\n /**\n * Append the std::string_view directly, without escaping.\n * There is no UTF-8 validation.\n */\n simdjson_inline void append_raw(std::string_view input) noexcept;\n\n /**\n * Append len characters from str.\n * There is no UTF-8 validation.\n */\n simdjson_inline void append_raw(const char *str, size_t len) noexcept;\n#if SIMDJSON_EXCEPTIONS\n /**\n * Creates an std::string from the written JSON buffer.\n * Throws if memory allocation failed\n *\n * The result may not be valid UTF-8 if some of your content was not valid UTF-8.\n * Use validate_unicode() to check the content if needed.\n */\n simdjson_inline operator std::string() const noexcept(false);\n\n /**\n * Creates an std::string_view from the written JSON buffer.\n * Throws if memory allocation failed.\n *\n * The result may not be valid UTF-8 if some of your content was not valid UTF-8.\n * Use validate_unicode() to check the content if needed.\n */\n simdjson_inline operator std::string_view() const noexcept(false) simdjson_lifetime_bound;\n#endif\n\n /**\n * Returns a view on the written JSON buffer. Returns an error\n * if memory allocation failed.\n *\n * The result may not be valid UTF-8 if some of your content was not valid UTF-8.\n * Use validate_unicode() to check the content.\n */\n simdjson_inline simdjson_result<std::string_view> view() const noexcept;\n\n /**\n * Appends the null character to the buffer and returns\n * a pointer to the beginning of the written JSON buffer.\n * Returns an error if memory allocation failed.\n * The result is null-terminated.\n *\n * The result may not be valid UTF-8 if some of your content was not valid UTF-8.\n * Use validate_unicode() to check the content.\n */\n simdjson_inline simdjson_result<const char *> c_str() noexcept;\n\n /**\n * Return true if the content is valid UTF-8.\n */\n simdjson_inline bool validate_unicode() const noexcept;\n\n /**\n * Returns the current size of the written JSON buffer.\n * If an error occurred, returns 0.\n */\n simdjson_inline size_t size() const noexcept;\n\nprivate:\n /**\n * Returns true if we can write at least upcoming_bytes bytes.\n * The underlying buffer is reallocated if needed. It is designed\n * to be called before writing to the buffer. It should be fast.\n */\n simdjson_inline bool capacity_check(size_t upcoming_bytes);\n\n /**\n * Grow the buffer to at least desired_capacity bytes.\n * If the allocation fails, is_valid is set to false. We expect\n * that this function would not be repeatedly called.\n */\n simdjson_inline void grow_buffer(size_t desired_capacity);\n\n /**\n * We use this helper function to make sure that is_valid is kept consistent.\n */\n simdjson_inline void set_valid(bool valid) noexcept;\n\n std::unique_ptr<char[]> buffer{};\n size_t position{0};\n size_t capacity{0};\n bool is_valid{true};\n};\n\n\n\n}\n}\n\n\n#if !SIMDJSON_STATIC_REFLECTION\n// fallback implementation until we have static reflection\ntemplate <class Z>\nsimdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = simdjson::lasx::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {\n simdjson::lasx::builder::string_builder b(initial_capacity);\n b.append(z);\n std::string_view s;\n auto e = b.view().get(s);\n if(e) { return e; }\n return std::string(s);\n}\ntemplate <class Z>\nsimdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::lasx::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {\n simdjson::lasx::builder::string_builder b(initial_capacity);\n b.append(z);\n std::string_view sv;\n auto e = b.view().get(sv);\n if(e) { return e; }\n s.assign(sv.data(), sv.size());\n return simdjson::SUCCESS;\n}\n#endif\n\n#if SIMDJSON_SUPPORTS_CONCEPTS\n#endif // SIMDJSON_SUPPORTS_CONCEPTS\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_STRING_BUILDER_H\n/* end file simdjson/generic/ondemand/json_string_builder.h for lasx */\n\n// All other declarations\n/* including simdjson/generic/ondemand/array.h for lasx: #include \"simdjson/generic/ondemand/array.h\" */\n/* begin file simdjson/generic/ondemand/array.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_ARRAY_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_ARRAY_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value_iterator.h\" */\n/* amalgamation skipped (editor-only): #include <vector> */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\n/**\n * A forward-only JSON array.\n */\nclass array {\npublic:\n /**\n * Create a new invalid array.\n *\n * Exists so you can declare a variable and later assign to it before use.\n */\n simdjson_inline array() noexcept = default;\n\n /**\n * Begin array iteration.\n *\n * Part of the std::iterable interface.\n */\n simdjson_inline simdjson_result<array_iterator> begin() noexcept;\n /**\n * Sentinel representing the end of the array.\n *\n * Part of the std::iterable interface.\n */\n simdjson_inline simdjson_result<array_iterator> end() noexcept;\n /**\n * This method scans the array and counts the number of elements.\n * The count_elements method should always be called before you have begun\n * iterating through the array: it is expected that you are pointing at\n * the beginning of the array.\n * The runtime complexity is linear in the size of the array. After\n * calling this function, if successful, the array is 'rewinded' at its\n * beginning as if it had never been accessed. If the JSON is malformed (e.g.,\n * there is a missing comma), then an error is returned and it is no longer\n * safe to continue. Note that count_elements() does not validate the JSON values,\n * only the structure of the array.\n *\n * To check that an array is empty, it is more performant to use\n * the is_empty() method.\n */\n simdjson_inline simdjson_result<size_t> count_elements() & noexcept;\n /**\n * This method scans the beginning of the array and checks whether the\n * array is empty.\n * The runtime complexity is constant time. After\n * calling this function, if successful, the array is 'rewinded' at its\n * beginning as if it had never been accessed. If the JSON is malformed (e.g.,\n * there is a missing comma), then an error is returned and it is no longer\n * safe to continue.\n */\n simdjson_inline simdjson_result<bool> is_empty() & noexcept;\n /**\n * Reset the iterator so that we are pointing back at the\n * beginning of the array. You should still consume values only once even if you\n * can iterate through the array more than once. If you unescape a string\n * within the array more than once, you have unsafe code. Note that rewinding\n * an array means that you may need to reparse it anew: it is not a free\n * operation.\n *\n * @returns true if the array contains some elements (not empty)\n */\n inline simdjson_result<bool> reset() & noexcept;\n /**\n * Get the value associated with the given JSON pointer. We use the RFC 6901\n * https://tools.ietf.org/html/rfc6901 standard, interpreting the current node\n * as the root of its own JSON document.\n *\n * ondemand::parser parser;\n * auto json = R\"([ { \"foo\": { \"a\": [ 10, 20, 30 ] }} ])\"_padded;\n * auto doc = parser.iterate(json);\n * doc.at_pointer(\"/0/foo/a/1\") == 20\n *\n * Note that at_pointer() called on the document automatically calls the document's rewind\n * method between each call. It invalidates all previously accessed arrays, objects and values\n * that have not been consumed. Yet it is not the case when calling at_pointer on an array\n * instance: there is no rewind and no invalidation.\n *\n * You may only call at_pointer on an array after it has been created, but before it has\n * been first accessed. When calling at_pointer on an array, the pointer is advanced to\n * the location indicated by the JSON pointer (in case of success). It is no longer possible\n * to call at_pointer on the same array.\n *\n * Also note that at_pointer() relies on find_field() which implies that we do not unescape keys when matching.\n *\n * @return The value associated with the given JSON pointer, or:\n * - NO_SUCH_FIELD if a field does not exist in an object\n * - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length\n * - INCORRECT_TYPE if a non-integer is used to access an array\n * - INVALID_JSON_POINTER if the JSON pointer is invalid and cannot be parsed\n */\n inline simdjson_result<value> at_pointer(std::string_view json_pointer) noexcept;\n\n /**\n * Get the value associated with the given JSONPath expression. We only support\n * JSONPath queries that trivially convertible to JSON Pointer queries: key\n * names and array indices.\n *\n * https://www.rfc-editor.org/rfc/rfc9535 (RFC 9535)\n *\n * @return The value associated with the given JSONPath expression, or:\n * - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails\n * - NO_SUCH_FIELD if a field does not exist in an object\n * - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length\n * - INCORRECT_TYPE if a non-integer is used to access an array\n */\n inline simdjson_result<value> at_path(std::string_view json_path) noexcept;\n\n /**\n * Get all values matching the given JSONPath expression with wildcard support.\n * Supports wildcard patterns like \"[*]\" to match all array elements.\n *\n * @param json_path JSONPath expression with wildcards\n * @return Vector of values matching the wildcard pattern\n */\n inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;\n\n /**\n * Consumes the array and returns a string_view instance corresponding to the\n * array as represented in JSON. It points inside the original document.\n */\n simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;\n\n /**\n * Get the value at the given index. This function has linear-time complexity.\n * This function should only be called once on an array instance since the array iterator is not reset between each call.\n *\n * @return The value at the given index, or:\n * - INDEX_OUT_OF_BOUNDS if the array index is larger than an array length\n */\n simdjson_inline simdjson_result<value> at(size_t index) noexcept;\n\n#if SIMDJSON_SUPPORTS_CONCEPTS\n /**\n * Get this array as the given type.\n *\n * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.\n * @returns INCORRECT_TYPE If the JSON array is not of the given type.\n * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.\n */\n template <typename T>\n simdjson_warn_unused simdjson_inline error_code get(T &out)\n noexcept(custom_deserializable<T, array> ? nothrow_custom_deserializable<T, array> : true) {\n static_assert(custom_deserializable<T, array>);\n return deserialize(*this, out);\n }\n /**\n * Get this array as the given type.\n *\n * @returns A value of the given type, parsed from the JSON.\n * @returns INCORRECT_TYPE If the JSON value is not the given type.\n */\n template <typename T>\n simdjson_inline simdjson_result<T> get()\n noexcept(custom_deserializable<T, value> ? nothrow_custom_deserializable<T, value> : true)\n {\n static_assert(std::is_default_constructible<T>::value, \"The specified type is not default constructible.\");\n T out{};\n SIMDJSON_TRY(get<T>(out));\n return out;\n }\n#endif // SIMDJSON_SUPPORTS_CONCEPTS\nprotected:\n /**\n * Go to the end of the array, no matter where you are right now.\n */\n simdjson_warn_unused simdjson_inline error_code consume() noexcept;\n\n /**\n * Begin array iteration.\n *\n * @param iter The iterator. Must be where the initial [ is expected. Will be *moved* into the\n * resulting array.\n * @error INCORRECT_TYPE if the iterator is not at [.\n */\n static simdjson_inline simdjson_result<array> start(value_iterator &iter) noexcept;\n /**\n * Begin array iteration from the root.\n *\n * @param iter The iterator. Must be where the initial [ is expected. Will be *moved* into the\n * resulting array.\n * @error INCORRECT_TYPE if the iterator is not at [.\n * @error TAPE_ERROR if there is no closing ] at the end of the document.\n */\n static simdjson_inline simdjson_result<array> start_root(value_iterator &iter) noexcept;\n /**\n * Begin array iteration.\n *\n * This version of the method should be called after the initial [ has been verified, and is\n * intended for use by switch statements that check the type of a value.\n *\n * @param iter The iterator. Must be after the initial [. Will be *moved* into the resulting array.\n */\n static simdjson_inline simdjson_result<array> started(value_iterator &iter) noexcept;\n\n /**\n * Create an array at the given Internal array creation. Call array::start() or array::started() instead of this.\n *\n * @param iter The iterator. Must either be at the start of the first element with iter.is_alive()\n * == true, or past the [] with is_alive() == false if the array is empty. Will be *moved*\n * into the resulting array.\n */\n simdjson_inline array(const value_iterator &iter) noexcept;\n\n /**\n * Iterator marking current position.\n *\n * iter.is_alive() == false indicates iteration is complete.\n */\n value_iterator iter{};\n\n friend class value;\n friend class document;\n friend struct simdjson_result<value>;\n friend struct simdjson_result<array>;\n friend class array_iterator;\n};\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\ntemplate<>\nstruct simdjson_result<lasx::ondemand::array> : public lasx::implementation_simdjson_result_base<lasx::ondemand::array> {\npublic:\n simdjson_inline simdjson_result(lasx::ondemand::array &&value) noexcept; ///< @private\n simdjson_inline simdjson_result(error_code error) noexcept; ///< @private\n simdjson_inline simdjson_result() noexcept = default;\n\n simdjson_inline simdjson_result<lasx::ondemand::array_iterator> begin() noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::array_iterator> end() noexcept;\n inline simdjson_result<size_t> count_elements() & noexcept;\n inline simdjson_result<bool> is_empty() & noexcept;\n inline simdjson_result<bool> reset() & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> at(size_t index) noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> at_path(std::string_view json_path) noexcept;\n simdjson_inline simdjson_result<std::vector<lasx::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;\n simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;\n#if SIMDJSON_SUPPORTS_CONCEPTS\n // TODO: move this code into object-inl.h\n\n template<typename T>\n simdjson_inline simdjson_result<T> get() noexcept {\n if (error()) { return error(); }\n if constexpr (std::is_same_v<T, lasx::ondemand::array>) {\n return first;\n }\n return first.get<T>();\n }\n template<typename T>\n simdjson_warn_unused simdjson_inline error_code get(T& out) noexcept {\n if (error()) { return error(); }\n if constexpr (std::is_same_v<T, lasx::ondemand::array>) {\n out = first;\n } else {\n SIMDJSON_TRY( first.get<T>(out) );\n }\n return SUCCESS;\n }\n#endif // SIMDJSON_SUPPORTS_CONCEPTS\n};\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_ARRAY_H\n/* end file simdjson/generic/ondemand/array.h for lasx */\n/* including simdjson/generic/ondemand/array_iterator.h for lasx: #include \"simdjson/generic/ondemand/array_iterator.h\" */\n/* begin file simdjson/generic/ondemand/array_iterator.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value_iterator.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\n/**\n * A forward-only JSON array.\n *\n * This is an input_iterator, meaning:\n * - It is forward-only\n * - * must be called exactly once per element.\n * - ++ must be called exactly once in between each * (*, ++, *, ++, * ...)\n */\nclass array_iterator {\npublic:\n /** Create a new, invalid array iterator. */\n simdjson_inline array_iterator() noexcept = default;\n\n //\n // Iterator interface\n //\n\n /**\n * Get the current element.\n *\n * Part of the std::iterator interface.\n */\n simdjson_inline simdjson_result<value>\n operator*() noexcept; // MUST ONLY BE CALLED ONCE PER ITERATION.\n /**\n * Check if we are at the end of the JSON.\n *\n * Part of the std::iterator interface.\n *\n * @return true if there are no more elements in the JSON array.\n */\n simdjson_inline bool operator==(const array_iterator &) const noexcept;\n /**\n * Check if there are more elements in the JSON array.\n *\n * Part of the std::iterator interface.\n *\n * @return true if there are more elements in the JSON array.\n */\n simdjson_inline bool operator!=(const array_iterator &) const noexcept;\n /**\n * Move to the next element.\n *\n * Part of the std::iterator interface.\n */\n simdjson_inline array_iterator &operator++() noexcept;\n\n /**\n * Check if the array is at the end.\n */\n simdjson_warn_unused simdjson_inline bool at_end() const noexcept;\n\nprivate:\n value_iterator iter{};\n\n simdjson_inline array_iterator(const value_iterator &iter) noexcept;\n\n friend class array;\n friend class value;\n friend struct simdjson_result<array_iterator>;\n};\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\ntemplate<>\nstruct simdjson_result<lasx::ondemand::array_iterator> : public lasx::implementation_simdjson_result_base<lasx::ondemand::array_iterator> {\n simdjson_inline simdjson_result(lasx::ondemand::array_iterator &&value) noexcept; ///< @private\n simdjson_inline simdjson_result(error_code error) noexcept; ///< @private\n simdjson_inline simdjson_result() noexcept = default;\n\n //\n // Iterator interface\n //\n\n simdjson_inline simdjson_result<lasx::ondemand::value> operator*() noexcept; // MUST ONLY BE CALLED ONCE PER ITERATION.\n simdjson_inline bool operator==(const simdjson_result<lasx::ondemand::array_iterator> &) const noexcept;\n simdjson_inline bool operator!=(const simdjson_result<lasx::ondemand::array_iterator> &) const noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::array_iterator> &operator++() noexcept;\n\n simdjson_warn_unused simdjson_inline bool at_end() const noexcept;\n};\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_H\n/* end file simdjson/generic/ondemand/array_iterator.h for lasx */\n/* including simdjson/generic/ondemand/document.h for lasx: #include \"simdjson/generic/ondemand/document.h\" */\n/* begin file simdjson/generic/ondemand/document.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/deserialize.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value.h\" */\n/* amalgamation skipped (editor-only): #include <vector> */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\n/**\n * A JSON document. It holds a json_iterator instance.\n *\n * Used by tokens to get text, and string buffer location.\n *\n * You must keep the document around during iteration.\n */\nclass document {\npublic:\n /**\n * Create a new invalid document.\n *\n * Exists so you can declare a variable and later assign to it before use.\n */\n simdjson_inline document() noexcept = default;\n simdjson_inline document(const document &other) noexcept = delete; // pass your documents by reference, not by copy\n simdjson_inline document(document &&other) noexcept = default;\n simdjson_inline document &operator=(const document &other) noexcept = delete;\n simdjson_inline document &operator=(document &&other) noexcept = default;\n\n /**\n * Cast this JSON value to an array.\n *\n * @returns An object that can be used to iterate the array.\n * @returns INCORRECT_TYPE If the JSON value is not an array.\n */\n simdjson_inline simdjson_result<array> get_array() & noexcept;\n /**\n * Cast this JSON value to an object.\n *\n * @returns An object that can be used to look up or iterate fields.\n * @returns INCORRECT_TYPE If the JSON value is not an object.\n */\n simdjson_inline simdjson_result<object> get_object() & noexcept;\n /**\n * Cast this JSON value to an unsigned integer.\n *\n * @returns A signed 64-bit integer.\n * @returns INCORRECT_TYPE If the JSON value is not a 64-bit unsigned integer.\n */\n simdjson_inline simdjson_result<uint64_t> get_uint64() noexcept;\n /**\n * Cast this JSON value (inside string) to an unsigned integer.\n *\n * @returns A signed 64-bit integer.\n * @returns INCORRECT_TYPE If the JSON value is not a 64-bit unsigned integer.\n */\n simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;\n /**\n * Cast this JSON value to a signed integer.\n *\n * @returns A signed 64-bit integer.\n * @returns INCORRECT_TYPE If the JSON value is not a 64-bit integer.\n */\n simdjson_inline simdjson_result<int64_t> get_int64() noexcept;\n /**\n * Cast this JSON value (inside string) to a signed integer.\n *\n * @returns A signed 64-bit integer.\n * @returns INCORRECT_TYPE If the JSON value is not a 64-bit integer.\n */\n simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;\n /**\n * Cast this JSON value to a double.\n *\n * @returns A double.\n * @returns INCORRECT_TYPE If the JSON value is not a valid floating-point number.\n */\n simdjson_inline simdjson_result<double> get_double() noexcept;\n\n /**\n * Cast this JSON value (inside string) to a double.\n *\n * @returns A double.\n * @returns INCORRECT_TYPE If the JSON value is not a valid floating-point number.\n */\n simdjson_inline simdjson_result<double> get_double_in_string() noexcept;\n /**\n * Cast this JSON value to a string.\n *\n * The string is guaranteed to be valid UTF-8.\n *\n * Important: Calling get_string() twice on the same document is an error.\n *\n * @param Whether to allow a replacement character for unmatched surrogate pairs.\n * @returns An UTF-8 string. The string is stored in the parser and will be invalidated the next\n * time it parses a document or when it is destroyed.\n * @returns INCORRECT_TYPE if the JSON value is not a string.\n */\n simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;\n /**\n * Attempts to fill the provided std::string reference with the parsed value of the current string.\n *\n * The string is guaranteed to be valid UTF-8.\n *\n * Important: a value should be consumed once. Calling get_string() twice on the same value\n * is an error.\n *\n * Performance: This method may be slower than get_string() or get_string(bool) because it may need to allocate memory.\n * We recommend you avoid allocating an std::string unless you need to.\n *\n * @returns INCORRECT_TYPE if the JSON value is not a string. Otherwise, we return SUCCESS.\n */\n template <typename string_type>\n simdjson_warn_unused simdjson_inline error_code get_string(string_type& receiver, bool allow_replacement = false) noexcept;\n /**\n * Cast this JSON value to a string.\n *\n * The string is not guaranteed to be valid UTF-8. See https://simonsapin.github.io/wtf-8/\n *\n * Important: Calling get_wobbly_string() twice on the same document is an error.\n *\n * @returns An UTF-8 string. The string is stored in the parser and will be invalidated the next\n * time it parses a document or when it is destroyed.\n * @returns INCORRECT_TYPE if the JSON value is not a string.\n */\n simdjson_inline simdjson_result<std::string_view> get_wobbly_string() noexcept;\n /**\n * Cast this JSON value to a raw_json_string.\n *\n * The string is guaranteed to be valid UTF-8, and may have escapes in it (e.g. \\\\ or \\n).\n *\n * @returns A pointer to the raw JSON for the given string.\n * @returns INCORRECT_TYPE if the JSON value is not a string.\n */\n simdjson_inline simdjson_result<raw_json_string> get_raw_json_string() noexcept;\n /**\n * Cast this JSON value to a bool.\n *\n * @returns A bool value.\n * @returns INCORRECT_TYPE if the JSON value is not true or false.\n */\n simdjson_inline simdjson_result<bool> get_bool() noexcept;\n /**\n * Cast this JSON value to a value when the document is an object or an array.\n *\n * You must not have begun iterating through the object or array. When\n * SIMDJSON_DEVELOPMENT_CHECKS is set to 1 (which is the case when building in Debug mode\n * by default), and you have already begun iterating,\n * you will get an OUT_OF_ORDER_ITERATION error. If you have begun iterating, you can use\n * rewind() to reset the document to its initial state before calling this method.\n *\n * @returns A value if a JSON array or object cannot be found.\n * @returns SCALAR_DOCUMENT_AS_VALUE error is the document is a scalar (see is_scalar() function).\n */\n simdjson_inline simdjson_result<value> get_value() noexcept;\n\n /**\n * Checks if this JSON value is null. If and only if the value is\n * null, then it is consumed (we advance). If we find a token that\n * begins with 'n' but is not 'null', then an error is returned.\n *\n * @returns Whether the value is null.\n * @returns INCORRECT_TYPE If the JSON value begins with 'n' and is not 'null'.\n */\n simdjson_inline simdjson_result<bool> is_null() noexcept;\n\n /**\n * Get this value as the given type.\n *\n * Supported types: object, array, raw_json_string, string_view, uint64_t, int64_t, double, bool\n *\n * You may use get_double(), get_bool(), get_uint64(), get_int64(),\n * get_object(), get_array(), get_raw_json_string(), or get_string() instead.\n *\n * @returns A value of the given type, parsed from the JSON.\n * @returns INCORRECT_TYPE If the JSON value is not the given type.\n */\n template <typename T>\n simdjson_inline simdjson_result<T> get() &\n#if SIMDJSON_SUPPORTS_CONCEPTS\n noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)\n#else\n noexcept\n#endif\n {\n static_assert(std::is_default_constructible<T>::value, \"Cannot initialize the specified type.\");\n T out{};\n SIMDJSON_TRY(get<T>(out));\n return out;\n }\n /**\n * @overload template<typename T> simdjson_result<T> get() & noexcept\n *\n * We disallow the use tag_invoke CPO on a moved document; it may create UB\n * if user uses `ondemand::array` or `ondemand::object` in their custom type.\n *\n * The member function is still remains specialize-able for compatibility\n * reasons, but we completely disallow its use when a tag_invoke customization\n * is provided.\n */\n template<typename T>\n simdjson_inline simdjson_result<T> get() &&\n#if SIMDJSON_SUPPORTS_CONCEPTS\n noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)\n#else\n noexcept\n#endif\n {\n static_assert(!std::is_same<T, array>::value && !std::is_same<T, object>::value, \"You should never hold either an ondemand::array or ondemand::object without a corresponding ondemand::document being alive; that would be Undefined Behaviour.\");\n return static_cast<document&>(*this).get<T>();\n }\n\n /**\n * Get this value as the given type.\n *\n * Supported types: object, array, raw_json_string, string_view, uint64_t, int64_t, double, bool, value\n *\n * Be mindful that the document instance must remain in scope while you are accessing object, array and value instances.\n *\n * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.\n * @returns INCORRECT_TYPE If the JSON value is of the given type.\n * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.\n */\n template<typename T>\n simdjson_warn_unused simdjson_inline error_code get(T &out) &\n#if SIMDJSON_SUPPORTS_CONCEPTS\n noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)\n#else\n noexcept\n#endif\n {\n#if SIMDJSON_SUPPORTS_CONCEPTS\n if constexpr (custom_deserializable<T, document>) {\n return deserialize(*this, out);\n } else {\n static_assert(!sizeof(T), \"The get<T> method with type T is not implemented by the simdjson library. \"\n \"And you do not seem to have added support for it. Indeed, we have that \"\n \"simdjson::custom_deserializable<T> is false and the type T is not a default type \"\n \"such as ondemand::object, ondemand::array, raw_json_string, std::string_view, uint64_t, \"\n \"int64_t, double, or bool.\");\n static_cast<void>(out); // to get rid of unused errors\n return UNINITIALIZED;\n }\n#else // SIMDJSON_SUPPORTS_CONCEPTS\n // Unless the simdjson library or the user provides an inline implementation, calling this method should\n // immediately fail.\n static_assert(!sizeof(T), \"The get method with given type is not implemented by the simdjson library. \"\n \"The supported types are ondemand::object, ondemand::array, raw_json_string, std::string_view, uint64_t, \"\n \"int64_t, double, and bool. We recommend you use get_double(), get_bool(), get_uint64(), get_int64(), \"\n \" get_object(), get_array(), get_raw_json_string(), or get_string() instead of the get template.\"\n \" You may also add support for custom types, see our documentation.\");\n static_cast<void>(out); // to get rid of unused errors\n return UNINITIALIZED;\n#endif // SIMDJSON_SUPPORTS_CONCEPTS\n }\n\n /** @overload template<typename T> error_code get(T &out) & noexcept */\n template<typename T> simdjson_deprecated simdjson_inline error_code get(T &out) && noexcept;\n\n#if SIMDJSON_EXCEPTIONS\n /**\n * Cast this JSON value to an instance of type T. The programmer is responsible for\n * providing an implementation of get<T> for the type T, if T is not one of the types\n * supported by the library (object, array, raw_json_string, string_view, uint64_t, etc.)\n *\n * See https://github.com/simdjson/simdjson/blob/master/doc/basics.md#adding-support-for-custom-types\n *\n * @returns An instance of type T\n */\n template <class T>\n explicit simdjson_inline operator T() & noexcept(false);\n template <class T>\n explicit simdjson_deprecated simdjson_inline operator T() && noexcept(false);\n\n /**\n * Cast this JSON value to an array.\n *\n * @returns An object that can be used to iterate the array.\n * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not an array.\n */\n simdjson_inline operator array() & noexcept(false);\n /**\n * Cast this JSON value to an object.\n *\n * @returns An object that can be used to look up or iterate fields.\n * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not an object.\n */\n simdjson_inline operator object() & noexcept(false);\n /**\n * Cast this JSON value to an unsigned integer.\n *\n * @returns A signed 64-bit integer.\n * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a 64-bit unsigned integer.\n */\n simdjson_inline operator uint64_t() noexcept(false);\n /**\n * Cast this JSON value to a signed integer.\n *\n * @returns A signed 64-bit integer.\n * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a 64-bit integer.\n */\n simdjson_inline operator int64_t() noexcept(false);\n /**\n * Cast this JSON value to a double.\n *\n * @returns A double.\n * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a valid floating-point number.\n */\n simdjson_inline operator double() noexcept(false);\n /**\n * Cast this JSON value to a string.\n *\n * The string is guaranteed to be valid UTF-8.\n *\n * @returns An UTF-8 string. The string is stored in the parser and will be invalidated the next\n * time it parses a document or when it is destroyed.\n * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not a string.\n */\n simdjson_inline operator std::string_view() noexcept(false) simdjson_lifetime_bound;\n /**\n * Cast this JSON value to a raw_json_string.\n *\n * The string is guaranteed to be valid UTF-8, and may have escapes in it (e.g. \\\\ or \\n).\n *\n * @returns A pointer to the raw JSON for the given string.\n * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not a string.\n */\n simdjson_inline operator raw_json_string() noexcept(false) simdjson_lifetime_bound;\n /**\n * Cast this JSON value to a bool.\n *\n * @returns A bool value.\n * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not true or false.\n */\n simdjson_inline operator bool() noexcept(false);\n /**\n * Cast this JSON value to a value when the document is an object or an array.\n *\n * You must not have begun iterating through the object or array. When\n * SIMDJSON_DEVELOPMENT_CHECKS is defined, and you have already begun iterating,\n * you will get an OUT_OF_ORDER_ITERATION error. If you have begun iterating, you can use\n * rewind() to reset the document to its initial state before calling this method.\n *\n * @returns A value value if a JSON array or object cannot be found.\n * @exception SCALAR_DOCUMENT_AS_VALUE error is the document is a scalar (see is_scalar() function).\n */\n simdjson_inline operator value() noexcept(false);\n#endif\n /**\n * This method scans the array and counts the number of elements.\n * The count_elements method should always be called before you have begun\n * iterating through the array: it is expected that you are pointing at\n * the beginning of the array.\n * The runtime complexity is linear in the size of the array. After\n * calling this function, if successful, the array is 'rewinded' at its\n * beginning as if it had never been accessed. If the JSON is malformed (e.g.,\n * there is a missing comma), then an error is returned and it is no longer\n * safe to continue. Note that count_elements() does not validate the JSON values,\n * only the structure of the array.\n */\n simdjson_inline simdjson_result<size_t> count_elements() & noexcept;\n /**\n * This method scans the object and counts the number of key-value pairs.\n * The count_fields method should always be called before you have begun\n * iterating through the object: it is expected that you are pointing at\n * the beginning of the object.\n * The runtime complexity is linear in the size of the object. After\n * calling this function, if successful, the object is 'rewinded' at its\n * beginning as if it had never been accessed. If the JSON is malformed (e.g.,\n * there is a missing comma), then an error is returned and it is no longer\n * safe to continue.\n *\n * To check that an object is empty, it is more performant to use\n * the is_empty() method.\n */\n simdjson_inline simdjson_result<size_t> count_fields() & noexcept;\n /**\n * Get the value at the given index in the array. This function has linear-time complexity.\n * This function should only be called once on an array instance since the array iterator is not reset between each call.\n *\n * @return The value at the given index, or:\n * - INDEX_OUT_OF_BOUNDS if the array index is larger than an array length\n */\n simdjson_inline simdjson_result<value> at(size_t index) & noexcept;\n /**\n * Begin array iteration.\n *\n * Part of the std::iterable interface.\n */\n simdjson_inline simdjson_result<array_iterator> begin() & noexcept;\n /**\n * Sentinel representing the end of the array.\n *\n * Part of the std::iterable interface.\n */\n simdjson_inline simdjson_result<array_iterator> end() & noexcept;\n\n /**\n * Look up a field by name on an object (order-sensitive).\n *\n * The following code reads z, then y, then x, and thus will not retrieve x or y if fed the\n * JSON `{ \"x\": 1, \"y\": 2, \"z\": 3 }`:\n *\n * ```cpp\n * simdjson::ondemand::parser parser;\n * auto obj = parser.parse(R\"( { \"x\": 1, \"y\": 2, \"z\": 3 } )\"_padded);\n * double z = obj.find_field(\"z\");\n * double y = obj.find_field(\"y\");\n * double x = obj.find_field(\"x\");\n * ```\n *\n * **Raw Keys:** The lookup will be done against the *raw* key, and will not unescape keys.\n * e.g. `object[\"a\"]` will match `{ \"a\": 1 }`, but will *not* match `{ \"\\u0061\": 1 }`.\n *\n *\n * You must consume the fields on an object one at a time. A request for a new key\n * invalidates previous field values: it makes them unsafe. E.g., the array\n * given by content[\"bids\"].get_array() should not be accessed after you have called\n * content[\"asks\"].get_array(). You can detect such mistakes by first compiling and running\n * the code in Debug mode (or with the macro `SIMDJSON_DEVELOPMENT_CHECKS` set to 1): an\n * OUT_OF_ORDER_ITERATION error is generated.\n *\n * You are expected to access keys only once. You should access the value corresponding to\n * a key a single time. Doing object[\"mykey\"].to_string()and then again object[\"mykey\"].to_string()\n * is an error.\n *\n * @param key The key to look up.\n * @returns The value of the field, or NO_SUCH_FIELD if the field is not in the object.\n */\n simdjson_inline simdjson_result<value> find_field(std::string_view key) & noexcept;\n /** @overload simdjson_inline simdjson_result<value> find_field(std::string_view key) & noexcept; */\n simdjson_inline simdjson_result<value> find_field(const char *key) & noexcept;\n\n /**\n * Look up a field by name on an object, without regard to key order.\n *\n * **Performance Notes:** This is a bit less performant than find_field(), though its effect varies\n * and often appears negligible. It starts out normally, starting out at the last field; but if\n * the field is not found, it scans from the beginning of the object to see if it missed it. That\n * missing case has a non-cache-friendly bump and lots of extra scanning, especially if the object\n * in question is large. The fact that the extra code is there also bumps the executable size.\n *\n * It is the default, however, because it would be highly surprising (and hard to debug) if the\n * default behavior failed to look up a field just because it was in the wrong order--and many\n * APIs assume this. Therefore, you must be explicit if you want to treat objects as out of order.\n *\n * Use find_field() if you are sure fields will be in order (or are willing to treat it as if the\n * field was not there when they are not in order).\n *\n * You must consume the fields on an object one at a time. A request for a new key\n * invalidates previous field values: it makes them unsafe. E.g., the array\n * given by content[\"bids\"].get_array() should not be accessed after you have called\n * content[\"asks\"].get_array(). You can detect such mistakes by first compiling and running\n * the code in Debug mode (or with the macro `SIMDJSON_DEVELOPMENT_CHECKS` set to 1): an\n * OUT_OF_ORDER_ITERATION error is generated.\n *\n * You are expected to access keys only once. You should access the value corresponding to a key\n * a single time. Doing object[\"mykey\"].to_string() and then again object[\"mykey\"].to_string()\n * is an error.\n *\n * @param key The key to look up.\n * @returns The value of the field, or NO_SUCH_FIELD if the field is not in the object.\n */\n simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept;\n /** @overload simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept; */\n simdjson_inline simdjson_result<value> find_field_unordered(const char *key) & noexcept;\n /** @overload simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept; */\n simdjson_inline simdjson_result<value> operator[](std::string_view key) & noexcept;\n /** @overload simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept; */\n simdjson_inline simdjson_result<value> operator[](const char *key) & noexcept;\n simdjson_result<value> operator[](int) & noexcept = delete;\n\n /**\n * Get the type of this JSON value. It does not validate or consume the value.\n * E.g., you must still call \"is_null()\" to check that a value is null even if\n * \"type()\" returns json_type::null.\n *\n * The answer can be one of\n * simdjson::ondemand::json_type::object,\n * simdjson::ondemand::json_type::array,\n * simdjson::ondemand::json_type::string,\n * simdjson::ondemand::json_type::number,\n * simdjson::ondemand::json_type::boolean,\n * simdjson::ondemand::json_type::null.\n *\n * Starting with simdjson 4.0, this function will return simdjson::ondemand::json_type::unknown\n * given a bad token.\n * This allows you to identify a case such as {\"key\": NaN} and identify the NaN value.\n * The simdjson::ondemand::json_type::unknown value should only happen with non-valid JSON.\n *\n * NOTE: If you're only expecting a value to be one type (a typical case), it's generally\n * better to just call .get_double, .get_string, etc. and check for INCORRECT_TYPE (or just\n * let it throw an exception).\n *\n * Prior to simdjson 4.0, this function would return an error given a bad token.\n * Starting with simdjson 4.0, it will return simdjson::ondemand::json_type::unknown.\n * This allows you to identify a case such as {\"key\": NaN} and identify the NaN value.\n * The simdjson::ondemand::json_type::unknown value should only happen with non-valid JSON.\n */\n simdjson_inline simdjson_result<json_type> type() noexcept;\n\n /**\n * Checks whether the document is a scalar (string, number, null, Boolean).\n * Returns false when there it is an array or object.\n *\n * @returns true if the type is string, number, null, Boolean\n * @error TAPE_ERROR when the JSON value is a bad token like \"}\" \",\" or \"alse\".\n */\n simdjson_inline simdjson_result<bool> is_scalar() noexcept;\n\n /**\n * Checks whether the document is a string.\n *\n * @returns true if the type is string\n * @error TAPE_ERROR when the JSON value is a bad token like \"}\" \",\" or \"alse\".\n */\n simdjson_inline simdjson_result<bool> is_string() noexcept;\n\n /**\n * Checks whether the document is a negative number.\n *\n * @returns true if the number if negative.\n */\n simdjson_inline bool is_negative() noexcept;\n /**\n * Checks whether the document is an integer number. Note that\n * this requires to partially parse the number string. If\n * the value is determined to be an integer, it may still\n * not parse properly as an integer in subsequent steps\n * (e.g., it might overflow).\n *\n * @returns true if the number if negative.\n */\n simdjson_inline simdjson_result<bool> is_integer() noexcept;\n /**\n * Determine the number type (integer or floating-point number) as quickly\n * as possible. This function does not fully validate the input. It is\n * useful when you only need to classify the numbers, without parsing them.\n *\n * If you are planning to retrieve the value or you need full validation,\n * consider using the get_number() method instead: it will fully parse\n * and validate the input, and give you access to the type:\n * get_number().get_number_type().\n *\n * get_number_type() is number_type::unsigned_integer if we have\n * an integer greater or equal to 9223372036854775808 and no larger than 18446744073709551615.\n * get_number_type() is number_type::signed_integer if we have an\n * integer that is less than 9223372036854775808 and greater or equal to -9223372036854775808.\n * get_number_type() is number_type::big_integer if we have an integer outside\n * of those ranges (either larger than 18446744073709551615 or smaller than -9223372036854775808).\n * Otherwise, get_number_type() has value number_type::floating_point_number\n *\n * This function requires processing the number string, but it is expected\n * to be faster than get_number().get_number_type() because it is does not\n * parse the number value.\n *\n * @returns the type of the number\n */\n simdjson_inline simdjson_result<number_type> get_number_type() noexcept;\n\n /**\n * Attempt to parse an ondemand::number. An ondemand::number may\n * contain an integer value or a floating-point value, the simdjson\n * library will autodetect the type. Thus it is a dynamically typed\n * number. Before accessing the value, you must determine the detected\n * type.\n *\n * number.get_number_type() is number_type::signed_integer if we have\n * an integer in [-9223372036854775808,9223372036854775808)\n * You can recover the value by calling number.get_int64() and you\n * have that number.is_int64() is true.\n *\n * number.get_number_type() is number_type::unsigned_integer if we have\n * an integer in [9223372036854775808,18446744073709551616)\n * You can recover the value by calling number.get_uint64() and you\n * have that number.is_uint64() is true.\n *\n * Otherwise, number.get_number_type() has value number_type::floating_point_number\n * and we have a binary64 number.\n * You can recover the value by calling number.get_double() and you\n * have that number.is_double() is true.\n *\n * You must check the type before accessing the value: it is an error\n * to call \"get_int64()\" when number.get_number_type() is not\n * number_type::signed_integer and when number.is_int64() is false.\n */\n simdjson_warn_unused simdjson_inline simdjson_result<number> get_number() noexcept;\n\n /**\n * Get the raw JSON for this token.\n *\n * The string_view will always point into the input buffer.\n *\n * The string_view will start at the beginning of the token, and include the entire token\n * *as well as all spaces until the next token (or EOF).* This means, for example, that a\n * string token always begins with a \" and is always terminated by the final \", possibly\n * followed by a number of spaces.\n *\n * The string_view is *not* null-terminated. If this is a scalar (string, number,\n * boolean, or null), the character after the end of the string_view may be the padded buffer.\n *\n * Tokens include:\n * - {\n * - [\n * - \"a string (possibly with UTF-8 or backslashed characters like \\\\\\\")\".\n * - -1.2e-100\n * - true\n * - false\n * - null\n */\n simdjson_inline simdjson_result<std::string_view> raw_json_token() noexcept;\n\n /**\n * Reset the iterator inside the document instance so we are pointing back at the\n * beginning of the document, as if it had just been created. It invalidates all\n * values, objects and arrays that you have created so far (including unescaped strings).\n */\n inline void rewind() noexcept;\n /**\n * Returns debugging information.\n */\n inline std::string to_debug_string() noexcept;\n /**\n * Some unrecoverable error conditions may render the document instance unusable.\n * The is_alive() method returns true when the document is still suitable.\n */\n inline bool is_alive() noexcept;\n\n /**\n * Returns the current location in the document if in bounds.\n */\n inline simdjson_result<const char *> current_location() const noexcept;\n\n /**\n * Returns true if this document has been fully parsed.\n * If you have consumed the whole document and at_end() returns\n * false, then there may be trailing content.\n */\n inline bool at_end() const noexcept;\n\n /**\n * Returns the current depth in the document if in bounds.\n *\n * E.g.,\n * 0 = finished with document\n * 1 = document root value (could be [ or {, not yet known)\n * 2 = , or } inside root array/object\n * 3 = key or value inside root array/object.\n */\n simdjson_inline int32_t current_depth() const noexcept;\n\n /**\n * Get the value associated with the given JSON pointer. We use the RFC 6901\n * https://tools.ietf.org/html/rfc6901 standard.\n *\n * ondemand::parser parser;\n * auto json = R\"({ \"foo\": { \"a\": [ 10, 20, 30 ] }})\"_padded;\n * auto doc = parser.iterate(json);\n * doc.at_pointer(\"/foo/a/1\") == 20\n *\n * It is allowed for a key to be the empty string:\n *\n * ondemand::parser parser;\n * auto json = R\"({ \"\": { \"a\": [ 10, 20, 30 ] }})\"_padded;\n * auto doc = parser.iterate(json);\n * doc.at_pointer(\"//a/1\") == 20\n *\n * Key values are matched exactly, without unescaping or Unicode normalization.\n * We do a byte-by-byte comparison. E.g.\n *\n * const padded_string json = \"{\\\"\\\\u00E9\\\":123}\"_padded;\n * auto doc = parser.iterate(json);\n * doc.at_pointer(\"/\\\\u00E9\") == 123\n * doc.at_pointer((const char*)u8\"/\\u00E9\") returns an error (NO_SUCH_FIELD)\n *\n * Note that at_pointer() automatically calls rewind between each call. Thus\n * all values, objects and arrays that you have created so far (including unescaped strings)\n * are invalidated. After calling at_pointer, you need to consume the result: string values\n * should be stored in your own variables, arrays should be decoded and stored in your own array-like\n * structures and so forth.\n *\n * Also note that at_pointer() relies on find_field() which implies that we do not unescape keys when matching\n *\n * @return The value associated with the given JSON pointer, or:\n * - NO_SUCH_FIELD if a field does not exist in an object\n * - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length\n * - INCORRECT_TYPE if a non-integer is used to access an array\n * - INVALID_JSON_POINTER if the JSON pointer is invalid and cannot be parsed\n * - SCALAR_DOCUMENT_AS_VALUE if the json_pointer is empty and the document is not a scalar (see is_scalar() function).\n */\n simdjson_inline simdjson_result<value> at_pointer(std::string_view json_pointer) noexcept;\n\n /**\n * Get the value associated with the given JSONPath expression. We only support\n * JSONPath queries that trivially convertible to JSON Pointer queries: key\n * names and array indices.\n *\n * https://www.rfc-editor.org/rfc/rfc9535 (RFC 9535)\n *\n * Key values are matched exactly, without unescaping or Unicode normalization.\n * We do a byte-by-byte comparison. E.g.\n *\n * const padded_string json = \"{\\\"\\\\u00E9\\\":123}\"_padded;\n * auto doc = parser.iterate(json);\n * doc.at_path(\".\\\\u00E9\") == 123\n * doc.at_path((const char*)u8\".\\u00E9\") returns an error (NO_SUCH_FIELD)\n *\n * @return The value associated with the given JSONPath expression, or:\n * - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails\n * - NO_SUCH_FIELD if a field does not exist in an object\n * - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length\n * - INCORRECT_TYPE if a non-integer is used to access an array\n */\n simdjson_inline simdjson_result<value> at_path(std::string_view json_path) noexcept;\n\n /**\n * Get all values matching the given JSONPath expression with wildcard support.\n *\n * Supports wildcard patterns like \"$.array[*]\" or \"$.object.*\" to match multiple elements.\n *\n * This method materializes all matching values into a vector.\n * The document will be consumed after this call.\n *\n * @param json_path JSONPath expression with wildcards\n * @return Vector of values matching the wildcard pattern, or:\n * - INVALID_JSON_POINTER if the JSONPath cannot be parsed\n * - NO_SUCH_FIELD if a field does not exist\n * - INDEX_OUT_OF_BOUNDS if an array index is out of bounds\n * - INCORRECT_TYPE if path traversal encounters wrong type\n */\n simdjson_inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;\n\n /**\n * Consumes the document and returns a string_view instance corresponding to the\n * document as represented in JSON. It points inside the original byte array containing\n * the JSON document.\n */\n simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;\n\n#if SIMDJSON_STATIC_REFLECTION\n /**\n * Extract only specific fields from the JSON object into a struct.\n *\n * This allows selective deserialization of only the fields you need,\n * potentially improving performance by skipping unwanted fields.\n *\n * Example:\n * ```cpp\n * struct Car {\n * std::string make;\n * std::string model;\n * int year;\n * double price;\n * };\n *\n * Car car;\n * doc.extract_into<\"make\", \"model\">(car);\n * // Only 'make' and 'model' fields are extracted from JSON\n * ```\n *\n * @tparam FieldNames Compile-time string literals specifying which fields to extract\n * @param out The output struct to populate with selected fields\n * @returns SUCCESS on success, or an error code if a required field is missing or has wrong type\n */\n template<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\n simdjson_warn_unused simdjson_inline error_code extract_into(T& out) & noexcept;\n#endif // SIMDJSON_STATIC_REFLECTION\nprotected:\n /**\n * Consumes the document.\n */\n simdjson_warn_unused simdjson_inline error_code consume() noexcept;\n\n simdjson_inline document(ondemand::json_iterator &&iter) noexcept;\n simdjson_inline const uint8_t *text(uint32_t idx) const noexcept;\n\n simdjson_inline value_iterator resume_value_iterator() noexcept;\n simdjson_inline value_iterator get_root_value_iterator() noexcept;\n simdjson_inline simdjson_result<object> start_or_resume_object() noexcept;\n static simdjson_inline document start(ondemand::json_iterator &&iter) noexcept;\n\n //\n // Fields\n //\n json_iterator iter{}; ///< Current position in the document\n static constexpr depth_t DOCUMENT_DEPTH = 0; ///< document depth is always 0\n\n friend class array_iterator;\n friend class value;\n friend class ondemand::parser;\n friend class object;\n friend class array;\n friend class field;\n friend class token;\n friend class document_stream;\n friend class document_reference;\n};\n\n\n/**\n * A document_reference is a thin wrapper around a document reference instance.\n * The document_reference instances are used primarily/solely for streams of JSON\n * documents. They differ from document instances when parsing a scalar value\n * (a document that is not an array or an object). In the case of a document,\n * we expect the document to be fully consumed. In the case of a document_reference,\n * we allow trailing content.\n */\nclass document_reference {\npublic:\n simdjson_inline document_reference() noexcept;\n simdjson_inline document_reference(document &d) noexcept;\n simdjson_inline document_reference(const document_reference &other) noexcept = default;\n simdjson_inline document_reference& operator=(const document_reference &other) noexcept = default;\n simdjson_inline void rewind() noexcept;\n simdjson_inline simdjson_result<array> get_array() & noexcept;\n simdjson_inline simdjson_result<object> get_object() & noexcept;\n simdjson_inline simdjson_result<uint64_t> get_uint64() noexcept;\n simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;\n simdjson_inline simdjson_result<int64_t> get_int64() noexcept;\n simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;\n simdjson_inline simdjson_result<double> get_double() noexcept;\n simdjson_inline simdjson_result<double> get_double_in_string() noexcept;\n simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;\n template <typename string_type>\n simdjson_warn_unused simdjson_inline error_code get_string(string_type& receiver, bool allow_replacement = false) noexcept;\n simdjson_inline simdjson_result<std::string_view> get_wobbly_string() noexcept;\n simdjson_inline simdjson_result<raw_json_string> get_raw_json_string() noexcept;\n simdjson_inline simdjson_result<bool> get_bool() noexcept;\n simdjson_inline simdjson_result<value> get_value() noexcept;\n\n simdjson_inline simdjson_result<bool> is_null() noexcept;\n template <typename T>\n simdjson_inline simdjson_result<T> get() &\n#if SIMDJSON_SUPPORTS_CONCEPTS\n noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)\n#else\n noexcept\n#endif\n {\n static_assert(std::is_default_constructible<T>::value, \"Cannot initialize the specified type.\");\n T out{};\n SIMDJSON_TRY(get<T>(out));\n return out;\n }\n template<typename T>\n simdjson_inline simdjson_result<T> get() &&\n#if SIMDJSON_SUPPORTS_CONCEPTS\n noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)\n#else\n noexcept\n#endif\n {\n static_assert(!std::is_same<T, array>::value && !std::is_same<T, object>::value, \"You should never hold either an ondemand::array or ondemand::object without a corresponding ondemand::document_reference being alive; that would be Undefined Behaviour.\");\n return static_cast<document&>(*this).get<T>();\n }\n\n /**\n * Get this value as the given type.\n *\n * Supported types: object, array, raw_json_string, string_view, uint64_t, int64_t, double, bool, value\n *\n * Be mindful that the document instance must remain in scope while you are accessing object, array and value instances.\n *\n * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.\n * @returns INCORRECT_TYPE If the JSON value is not an object.\n * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.\n */\n template<typename T>\n simdjson_warn_unused simdjson_inline error_code get(T &out) &\n#if SIMDJSON_SUPPORTS_CONCEPTS\n noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document_reference> : true)\n#else\n noexcept\n#endif\n {\n#if SIMDJSON_SUPPORTS_CONCEPTS\n if constexpr (custom_deserializable<T, document_reference>) {\n return deserialize(*this, out);\n } else {\n static_assert(!sizeof(T), \"The get<T> method with type T is not implemented by the simdjson library. \"\n \"And you do not seem to have added support for it. Indeed, we have that \"\n \"simdjson::custom_deserializable<T> is false and the type T is not a default type \"\n \"such as ondemand::object, ondemand::array, raw_json_string, std::string_view, uint64_t, \"\n \"int64_t, double, or bool.\");\n static_cast<void>(out); // to get rid of unused errors\n return UNINITIALIZED;\n }\n#else // SIMDJSON_SUPPORTS_CONCEPTS\n // Unless the simdjson library or the user provides an inline implementation, calling this method should\n // immediately fail.\n static_assert(!sizeof(T), \"The get method with given type is not implemented by the simdjson library. \"\n \"The supported types are ondemand::object, ondemand::array, raw_json_string, std::string_view, uint64_t, \"\n \"int64_t, double, and bool. We recommend you use get_double(), get_bool(), get_uint64(), get_int64(), \"\n \" get_object(), get_array(), get_raw_json_string(), or get_string() instead of the get template.\"\n \" You may also add support for custom types, see our documentation.\");\n static_cast<void>(out); // to get rid of unused errors\n return UNINITIALIZED;\n#endif // SIMDJSON_SUPPORTS_CONCEPTS\n }\n\n /** @overload template<typename T> error_code get(T &out) & noexcept */\n template<typename T> simdjson_inline error_code get(T &out) && noexcept;\n simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;\n#if SIMDJSON_STATIC_REFLECTION\n template<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\n simdjson_warn_unused simdjson_inline error_code extract_into(T& out) & noexcept;\n#endif // SIMDJSON_STATIC_REFLECTION\n simdjson_inline operator document&() const noexcept;\n#if SIMDJSON_EXCEPTIONS\n template <class T>\n explicit simdjson_inline operator T() noexcept(false);\n simdjson_inline operator array() & noexcept(false);\n simdjson_inline operator object() & noexcept(false);\n simdjson_inline operator uint64_t() noexcept(false);\n simdjson_inline operator int64_t() noexcept(false);\n simdjson_inline operator double() noexcept(false);\n simdjson_inline operator std::string_view() noexcept(false);\n simdjson_inline operator raw_json_string() noexcept(false);\n simdjson_inline operator bool() noexcept(false);\n simdjson_inline operator value() noexcept(false);\n#endif\n simdjson_inline simdjson_result<size_t> count_elements() & noexcept;\n simdjson_inline simdjson_result<size_t> count_fields() & noexcept;\n simdjson_inline simdjson_result<value> at(size_t index) & noexcept;\n simdjson_inline simdjson_result<array_iterator> begin() & noexcept;\n simdjson_inline simdjson_result<array_iterator> end() & noexcept;\n simdjson_inline simdjson_result<value> find_field(std::string_view key) & noexcept;\n simdjson_inline simdjson_result<value> find_field(const char *key) & noexcept;\n simdjson_inline simdjson_result<value> operator[](std::string_view key) & noexcept;\n simdjson_inline simdjson_result<value> operator[](const char *key) & noexcept;\n simdjson_result<value> operator[](int) & noexcept = delete;\n simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept;\n simdjson_inline simdjson_result<value> find_field_unordered(const char *key) & noexcept;\n\n simdjson_inline simdjson_result<json_type> type() noexcept;\n simdjson_inline simdjson_result<bool> is_scalar() noexcept;\n simdjson_inline simdjson_result<bool> is_string() noexcept;\n\n simdjson_inline simdjson_result<const char *> current_location() noexcept;\n simdjson_inline int32_t current_depth() const noexcept;\n simdjson_inline bool is_negative() noexcept;\n simdjson_inline simdjson_result<bool> is_integer() noexcept;\n simdjson_inline simdjson_result<number_type> get_number_type() noexcept;\n simdjson_inline simdjson_result<number> get_number() noexcept;\n simdjson_inline simdjson_result<std::string_view> raw_json_token() noexcept;\n simdjson_inline simdjson_result<value> at_pointer(std::string_view json_pointer) noexcept;\n simdjson_inline simdjson_result<value> at_path(std::string_view json_path) noexcept;\n simdjson_inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;\n\nprivate:\n document *doc{nullptr};\n};\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\ntemplate<>\nstruct simdjson_result<lasx::ondemand::document> : public lasx::implementation_simdjson_result_base<lasx::ondemand::document> {\npublic:\n simdjson_inline simdjson_result(lasx::ondemand::document &&value) noexcept; ///< @private\n simdjson_inline simdjson_result(error_code error) noexcept; ///< @private\n simdjson_inline simdjson_result() noexcept = default;\n simdjson_inline error_code rewind() noexcept;\n\n simdjson_inline simdjson_result<lasx::ondemand::array> get_array() & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::object> get_object() & noexcept;\n simdjson_inline simdjson_result<uint64_t> get_uint64() noexcept;\n simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;\n simdjson_inline simdjson_result<int64_t> get_int64() noexcept;\n simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;\n simdjson_inline simdjson_result<double> get_double() noexcept;\n simdjson_inline simdjson_result<double> get_double_in_string() noexcept;\n simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;\n template <typename string_type>\n simdjson_warn_unused simdjson_inline error_code get_string(string_type& receiver, bool allow_replacement = false) noexcept;\n simdjson_inline simdjson_result<std::string_view> get_wobbly_string() noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::raw_json_string> get_raw_json_string() noexcept;\n simdjson_inline simdjson_result<bool> get_bool() noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> get_value() noexcept;\n simdjson_inline simdjson_result<bool> is_null() noexcept;\n\n template<typename T> simdjson_inline simdjson_result<T> get() & noexcept;\n template<typename T> simdjson_deprecated simdjson_inline simdjson_result<T> get() && noexcept;\n\n template<typename T> simdjson_inline error_code get(T &out) & noexcept;\n template<typename T> simdjson_inline error_code get(T &out) && noexcept;\n#if SIMDJSON_EXCEPTIONS\n\n using lasx::implementation_simdjson_result_base<lasx::ondemand::document>::operator*;\n using lasx::implementation_simdjson_result_base<lasx::ondemand::document>::operator->;\n template <class T, typename std::enable_if<std::is_same<T, lasx::ondemand::document>::value == false>::type>\n explicit simdjson_inline operator T() noexcept(false);\n simdjson_inline operator lasx::ondemand::array() & noexcept(false);\n simdjson_inline operator lasx::ondemand::object() & noexcept(false);\n simdjson_inline operator uint64_t() noexcept(false);\n simdjson_inline operator int64_t() noexcept(false);\n simdjson_inline operator double() noexcept(false);\n simdjson_inline operator std::string_view() noexcept(false);\n simdjson_inline operator lasx::ondemand::raw_json_string() noexcept(false);\n simdjson_inline operator bool() noexcept(false);\n simdjson_inline operator lasx::ondemand::value() noexcept(false);\n#endif\n simdjson_inline simdjson_result<size_t> count_elements() & noexcept;\n simdjson_inline simdjson_result<size_t> count_fields() & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> at(size_t index) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::array_iterator> begin() & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::array_iterator> end() & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> find_field(std::string_view key) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> find_field(const char *key) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> operator[](std::string_view key) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> operator[](const char *key) & noexcept;\n simdjson_result<lasx::ondemand::value> operator[](int) & noexcept = delete;\n simdjson_inline simdjson_result<lasx::ondemand::value> find_field_unordered(std::string_view key) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> find_field_unordered(const char *key) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::json_type> type() noexcept;\n simdjson_inline simdjson_result<bool> is_scalar() noexcept;\n simdjson_inline simdjson_result<bool> is_string() noexcept;\n simdjson_inline simdjson_result<const char *> current_location() noexcept;\n simdjson_inline int32_t current_depth() const noexcept;\n simdjson_inline bool at_end() const noexcept;\n simdjson_inline bool is_negative() noexcept;\n simdjson_inline simdjson_result<bool> is_integer() noexcept;\n simdjson_inline simdjson_result<lasx::number_type> get_number_type() noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::number> get_number() noexcept;\n /** @copydoc simdjson_inline std::string_view document::raw_json_token() const noexcept */\n simdjson_inline simdjson_result<std::string_view> raw_json_token() noexcept;\n\n simdjson_inline simdjson_result<lasx::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> at_path(std::string_view json_path) noexcept;\n simdjson_inline simdjson_result<std::vector<lasx::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;\n#if SIMDJSON_STATIC_REFLECTION\n template<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\n simdjson_warn_unused simdjson_inline error_code extract_into(T& out) & noexcept;\n#endif // SIMDJSON_STATIC_REFLECTION\n};\n\n\n} // namespace simdjson\n\n\n\nnamespace simdjson {\n\ntemplate<>\nstruct simdjson_result<lasx::ondemand::document_reference> : public lasx::implementation_simdjson_result_base<lasx::ondemand::document_reference> {\npublic:\n simdjson_inline simdjson_result(lasx::ondemand::document_reference value, error_code error) noexcept;\n simdjson_inline simdjson_result() noexcept = default;\n simdjson_inline error_code rewind() noexcept;\n\n simdjson_inline simdjson_result<lasx::ondemand::array> get_array() & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::object> get_object() & noexcept;\n simdjson_inline simdjson_result<uint64_t> get_uint64() noexcept;\n simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;\n simdjson_inline simdjson_result<int64_t> get_int64() noexcept;\n simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;\n simdjson_inline simdjson_result<double> get_double() noexcept;\n simdjson_inline simdjson_result<double> get_double_in_string() noexcept;\n simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;\n template <typename string_type>\n simdjson_warn_unused simdjson_inline error_code get_string(string_type& receiver, bool allow_replacement = false) noexcept;\n simdjson_inline simdjson_result<std::string_view> get_wobbly_string() noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::raw_json_string> get_raw_json_string() noexcept;\n simdjson_inline simdjson_result<bool> get_bool() noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> get_value() noexcept;\n simdjson_inline simdjson_result<bool> is_null() noexcept;\n\n template<typename T> simdjson_inline simdjson_result<T> get() & noexcept;\n template<typename T> simdjson_inline simdjson_result<T> get() && noexcept;\n\n template<typename T> simdjson_inline error_code get(T &out) & noexcept;\n template<typename T> simdjson_inline error_code get(T &out) && noexcept;\n#if SIMDJSON_EXCEPTIONS\n template <class T>\n explicit simdjson_inline operator T() noexcept(false);\n simdjson_inline operator lasx::ondemand::array() & noexcept(false);\n simdjson_inline operator lasx::ondemand::object() & noexcept(false);\n simdjson_inline operator uint64_t() noexcept(false);\n simdjson_inline operator int64_t() noexcept(false);\n simdjson_inline operator double() noexcept(false);\n simdjson_inline operator std::string_view() noexcept(false);\n simdjson_inline operator lasx::ondemand::raw_json_string() noexcept(false);\n simdjson_inline operator bool() noexcept(false);\n simdjson_inline operator lasx::ondemand::value() noexcept(false);\n#endif\n simdjson_inline simdjson_result<size_t> count_elements() & noexcept;\n simdjson_inline simdjson_result<size_t> count_fields() & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> at(size_t index) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::array_iterator> begin() & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::array_iterator> end() & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> find_field(std::string_view key) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> find_field(const char *key) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> operator[](std::string_view key) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> operator[](const char *key) & noexcept;\n simdjson_result<lasx::ondemand::value> operator[](int) & noexcept = delete;\n simdjson_inline simdjson_result<lasx::ondemand::value> find_field_unordered(std::string_view key) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> find_field_unordered(const char *key) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::json_type> type() noexcept;\n simdjson_inline simdjson_result<bool> is_scalar() noexcept;\n simdjson_inline simdjson_result<bool> is_string() noexcept;\n simdjson_inline simdjson_result<const char *> current_location() noexcept;\n simdjson_inline simdjson_result<int32_t> current_depth() const noexcept;\n simdjson_inline simdjson_result<bool> is_negative() noexcept;\n simdjson_inline simdjson_result<bool> is_integer() noexcept;\n simdjson_inline simdjson_result<lasx::number_type> get_number_type() noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::number> get_number() noexcept;\n /** @copydoc simdjson_inline std::string_view document_reference::raw_json_token() const noexcept */\n simdjson_inline simdjson_result<std::string_view> raw_json_token() noexcept;\n\n simdjson_inline simdjson_result<lasx::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> at_path(std::string_view json_path) noexcept;\n simdjson_inline simdjson_result<std::vector<lasx::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;\n#if SIMDJSON_STATIC_REFLECTION\n template<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\n simdjson_warn_unused simdjson_inline error_code extract_into(T& out) & noexcept;\n#endif // SIMDJSON_STATIC_REFLECTION\n};\n\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_H\n/* end file simdjson/generic/ondemand/document.h for lasx */\n/* including simdjson/generic/ondemand/document_stream.h for lasx: #include \"simdjson/generic/ondemand/document_stream.h\" */\n/* begin file simdjson/generic/ondemand/document_stream.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/document.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/parser.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\n#ifdef SIMDJSON_THREADS_ENABLED\n#include <thread>\n#include <mutex>\n#include <condition_variable>\n#endif\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\n#ifdef SIMDJSON_THREADS_ENABLED\n/** @private Custom worker class **/\nstruct stage1_worker {\n stage1_worker() noexcept = default;\n stage1_worker(const stage1_worker&) = delete;\n stage1_worker(stage1_worker&&) = delete;\n stage1_worker operator=(const stage1_worker&) = delete;\n ~stage1_worker();\n /**\n * We only start the thread when it is needed, not at object construction, this may throw.\n * You should only call this once.\n **/\n void start_thread();\n /**\n * Start a stage 1 job. You should first call 'run', then 'finish'.\n * You must call start_thread once before.\n */\n void run(document_stream * ds, parser * stage1, size_t next_batch_start);\n /** Wait for the run to finish (blocking). You should first call 'run', then 'finish'. **/\n void finish();\n\nprivate:\n\n /**\n * Normally, we would never stop the thread. But we do in the destructor.\n * This function is only safe assuming that you are not waiting for results. You\n * should have called run, then finish, and be done.\n **/\n void stop_thread();\n\n std::thread thread{};\n /** These three variables define the work done by the thread. **/\n ondemand::parser * stage1_thread_parser{};\n size_t _next_batch_start{};\n document_stream * owner{};\n /**\n * We have two state variables. This could be streamlined to one variable in the future but\n * we use two for clarity.\n */\n bool has_work{false};\n bool can_work{true};\n\n /**\n * We lock using a mutex.\n */\n std::mutex locking_mutex{};\n std::condition_variable cond_var{};\n\n friend class document_stream;\n};\n#endif // SIMDJSON_THREADS_ENABLED\n\n/**\n * A forward-only stream of documents.\n *\n * Produced by parser::iterate_many.\n *\n */\nclass document_stream {\npublic:\n /**\n * Construct an uninitialized document_stream.\n *\n * ```cpp\n * document_stream docs;\n * auto error = parser.iterate_many(json).get(docs);\n * ```\n */\n simdjson_inline document_stream() noexcept;\n /** Move one document_stream to another. */\n simdjson_inline document_stream(document_stream &&other) noexcept = default;\n /** Move one document_stream to another. */\n simdjson_inline document_stream &operator=(document_stream &&other) noexcept = default;\n\n simdjson_inline ~document_stream() noexcept;\n\n /**\n * Returns the input size in bytes.\n */\n inline size_t size_in_bytes() const noexcept;\n\n /**\n * After iterating through the stream, this method\n * returns the number of bytes that were not parsed at the end\n * of the stream. If truncated_bytes() differs from zero,\n * then the input was truncated maybe because incomplete JSON\n * documents were found at the end of the stream. You\n * may need to process the bytes in the interval [size_in_bytes()-truncated_bytes(), size_in_bytes()).\n *\n * You should only call truncated_bytes() after streaming through all\n * documents, like so:\n *\n * document_stream stream = parser.iterate_many(json,window);\n * for(auto & doc : stream) {\n * // do something with doc\n * }\n * size_t truncated = stream.truncated_bytes();\n *\n */\n inline size_t truncated_bytes() const noexcept;\n\n class iterator {\n public:\n using value_type = simdjson_result<document>;\n using reference = simdjson_result<ondemand::document_reference>;\n using pointer = void;\n using difference_type = std::ptrdiff_t;\n using iterator_category = std::input_iterator_tag;\n\n /**\n * Default constructor.\n */\n simdjson_inline iterator() noexcept;\n simdjson_inline iterator(const iterator &other) noexcept = default;\n /**\n * Get the current document (or error).\n */\n simdjson_inline reference operator*() noexcept;\n /**\n * Advance to the next document (prefix).\n */\n inline iterator& operator++() noexcept;\n /**\n * Check if we're at the end yet.\n * @param other the end iterator to compare to.\n */\n simdjson_inline bool operator!=(const iterator &other) const noexcept;\n simdjson_inline bool operator==(const iterator &other) const noexcept;\n /**\n * @private\n *\n * Gives the current index in the input document in bytes.\n *\n * document_stream stream = parser.parse_many(json,window);\n * for(auto i = stream.begin(); i != stream.end(); ++i) {\n * auto doc = *i;\n * size_t index = i.current_index();\n * }\n *\n * This function (current_index()) is experimental and the usage\n * may change in future versions of simdjson: we find the API somewhat\n * awkward and we would like to offer something friendlier.\n */\n simdjson_inline size_t current_index() const noexcept;\n\n /**\n * @private\n *\n * Gives a view of the current document at the current position.\n *\n * document_stream stream = parser.iterate_many(json,window);\n * for(auto i = stream.begin(); i != stream.end(); ++i) {\n * std::string_view v = i.source();\n * }\n *\n * The returned string_view instance is simply a map to the (unparsed)\n * source string: it may thus include white-space characters and all manner\n * of padding.\n *\n * This function (source()) is experimental and the usage\n * may change in future versions of simdjson: we find the API somewhat\n * awkward and we would like to offer something friendlier.\n *\n */\n simdjson_inline std::string_view source() const noexcept;\n\n /**\n * Returns error of the stream (if any).\n */\n inline error_code error() const noexcept;\n\n /**\n * Returns whether the iterator is at the end.\n */\n inline bool at_end() const noexcept;\n\n private:\n simdjson_inline iterator(document_stream *s, bool finished) noexcept;\n /** The document_stream we're iterating through. */\n document_stream* stream;\n /** Whether we're finished or not. */\n bool finished;\n\n friend class document;\n friend class document_stream;\n friend class json_iterator;\n };\n using iterator = document_stream::iterator;\n\n /**\n * Start iterating the documents in the stream.\n */\n simdjson_inline iterator begin() noexcept;\n /**\n * The end of the stream, for iterator comparison purposes.\n */\n simdjson_inline iterator end() noexcept;\n\nprivate:\n\n document_stream &operator=(const document_stream &) = delete; // Disallow copying\n document_stream(const document_stream &other) = delete; // Disallow copying\n\n /**\n * Construct a document_stream. Does not allocate or parse anything until the iterator is\n * used.\n *\n * @param parser is a reference to the parser instance used to generate this document_stream\n * @param buf is the raw byte buffer we need to process\n * @param len is the length of the raw byte buffer in bytes\n * @param batch_size is the size of the windows (must be strictly greater or equal to the largest JSON document)\n */\n simdjson_inline document_stream(\n ondemand::parser &parser,\n const uint8_t *buf,\n size_t len,\n size_t batch_size,\n bool allow_comma_separated\n ) noexcept;\n\n /**\n * Parse the first document in the buffer. Used by begin(), to handle allocation and\n * initialization.\n */\n inline void start() noexcept;\n\n /**\n * Parse the next document found in the buffer previously given to document_stream.\n *\n * The content should be a valid JSON document encoded as UTF-8. If there is a\n * UTF-8 BOM, the parser skips it.\n *\n * You do NOT need to pre-allocate a parser. This function takes care of\n * pre-allocating a capacity defined by the batch_size defined when creating the\n * document_stream object.\n *\n * The function returns simdjson::EMPTY if there is no more data to be parsed.\n *\n * The function returns simdjson::SUCCESS (as integer = 0) in case of success\n * and indicates that the buffer has successfully been parsed to the end.\n * Every document it contained has been parsed without error.\n *\n * The function returns an error code from simdjson/simdjson.h in case of failure\n * such as simdjson::CAPACITY, simdjson::MEMALLOC, simdjson::DEPTH_ERROR and so forth;\n * the simdjson::error_message function converts these error codes into a string).\n *\n * You can also check validity by calling parser.is_valid(). The same parser can\n * and should be reused for the other documents in the buffer.\n */\n inline void next() noexcept;\n\n /** Move the json_iterator of the document to the location of the next document in the stream. */\n inline void next_document() noexcept;\n\n /** Get the next document index. */\n inline size_t next_batch_start() const noexcept;\n\n /** Pass the next batch through stage 1 with the given parser. */\n inline error_code run_stage1(ondemand::parser &p, size_t batch_start) noexcept;\n\n // Fields\n ondemand::parser *parser;\n const uint8_t *buf;\n size_t len;\n size_t batch_size;\n bool allow_comma_separated;\n /**\n * We are going to use just one document instance. The document owns\n * the json_iterator. It implies that we only ever pass a reference\n * to the document to the users.\n */\n document doc{};\n /** The error (or lack thereof) from the current document. */\n error_code error;\n size_t batch_start{0};\n size_t doc_index{};\n\n #ifdef SIMDJSON_THREADS_ENABLED\n /** Indicates whether we use threads. Note that this needs to be a constant during the execution of the parsing. */\n bool use_thread;\n\n inline void load_from_stage1_thread() noexcept;\n\n /** Start a thread to run stage 1 on the next batch. */\n inline void start_stage1_thread() noexcept;\n\n /** Wait for the stage 1 thread to finish and capture the results. */\n inline void finish_stage1_thread() noexcept;\n\n /** The error returned from the stage 1 thread. */\n error_code stage1_thread_error{UNINITIALIZED};\n /** The thread used to run stage 1 against the next batch in the background. */\n std::unique_ptr<stage1_worker> worker{new(std::nothrow) stage1_worker()};\n /**\n * The parser used to run stage 1 in the background. Will be swapped\n * with the regular parser when finished.\n */\n ondemand::parser stage1_thread_parser{};\n\n friend struct stage1_worker;\n #endif // SIMDJSON_THREADS_ENABLED\n\n friend class parser;\n friend class document;\n friend class json_iterator;\n friend struct simdjson_result<ondemand::document_stream>;\n friend struct simdjson::internal::simdjson_result_base<ondemand::document_stream>;\n}; // document_stream\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\ntemplate<>\nstruct simdjson_result<lasx::ondemand::document_stream> : public lasx::implementation_simdjson_result_base<lasx::ondemand::document_stream> {\npublic:\n simdjson_inline simdjson_result(lasx::ondemand::document_stream &&value) noexcept; ///< @private\n simdjson_inline simdjson_result(error_code error) noexcept; ///< @private\n simdjson_inline simdjson_result() noexcept = default;\n};\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_H\n/* end file simdjson/generic/ondemand/document_stream.h for lasx */\n/* including simdjson/generic/ondemand/field.h for lasx: #include \"simdjson/generic/ondemand/field.h\" */\n/* begin file simdjson/generic/ondemand/field.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_FIELD_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_FIELD_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/raw_json_string.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\n/**\n * A JSON field (key/value pair) in an object.\n *\n * Returned from object iteration.\n *\n * Extends from std::pair<raw_json_string, value> so you can use C++ algorithms that rely on pairs.\n */\nclass field : public std::pair<raw_json_string, value> {\npublic:\n /**\n * Create a new invalid field.\n *\n * Exists so you can declare a variable and later assign to it before use.\n */\n simdjson_inline field() noexcept;\n\n /**\n * Get the key as a string_view (for higher speed, consider raw_key).\n * We deliberately use a more cumbersome name (unescaped_key) to force users\n * to think twice about using it.\n *\n * This consumes the key: once you have called unescaped_key(), you cannot\n * call it again nor can you call key().\n */\n simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> unescaped_key(bool allow_replacement = false) noexcept;\n /**\n * Get the key as a string_view (for higher speed, consider raw_key).\n * We deliberately use a more cumbersome name (unescaped_key) to force users\n * to think twice about using it. The content is stored in the receiver.\n *\n * This consumes the key: once you have called unescaped_key(), you cannot\n * call it again nor can you call key().\n */\n template <typename string_type>\n simdjson_inline simdjson_warn_unused error_code unescaped_key(string_type& receiver, bool allow_replacement = false) noexcept;\n /**\n * Get the key as a raw_json_string. Can be used for direct comparison with\n * an unescaped C string: e.g., key() == \"test\". This does not count as\n * consumption of the content: you can safely call it repeatedly.\n * See escaped_key() for a similar function which returns\n * a more convenient std::string_view result.\n */\n simdjson_inline raw_json_string key() const noexcept;\n /**\n * Get the unprocessed key as a string_view. This includes the quotes and may include\n * some spaces after the last quote. This does not count as\n * consumption of the content: you can safely call it repeatedly.\n * See escaped_key().\n */\n simdjson_inline std::string_view key_raw_json_token() const noexcept;\n /**\n * Get the key as a string_view. This does not include the quotes and\n * the string is unprocessed key so it may contain escape characters\n * (e.g., \\uXXXX or \\n). It does not count as a consumption of the content:\n * you can safely call it repeatedly. Use unescaped_key() to get the unescaped key.\n */\n simdjson_inline std::string_view escaped_key() const noexcept;\n /**\n * Get the field value.\n */\n simdjson_inline ondemand::value &value() & noexcept;\n /**\n * @overload ondemand::value &ondemand::value() & noexcept\n */\n simdjson_inline ondemand::value value() && noexcept;\n\nprotected:\n simdjson_inline field(raw_json_string key, ondemand::value &&value) noexcept;\n static simdjson_inline simdjson_result<field> start(value_iterator &parent_iter) noexcept;\n static simdjson_inline simdjson_result<field> start(const value_iterator &parent_iter, raw_json_string key) noexcept;\n friend struct simdjson_result<field>;\n friend class object_iterator;\n};\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\ntemplate<>\nstruct simdjson_result<lasx::ondemand::field> : public lasx::implementation_simdjson_result_base<lasx::ondemand::field> {\npublic:\n simdjson_inline simdjson_result(lasx::ondemand::field &&value) noexcept; ///< @private\n simdjson_inline simdjson_result(error_code error) noexcept; ///< @private\n simdjson_inline simdjson_result() noexcept = default;\n\n simdjson_inline simdjson_result<std::string_view> unescaped_key(bool allow_replacement = false) noexcept;\n template<typename string_type>\n simdjson_inline error_code unescaped_key(string_type &receiver, bool allow_replacement = false) noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::raw_json_string> key() noexcept;\n simdjson_inline simdjson_result<std::string_view> key_raw_json_token() noexcept;\n simdjson_inline simdjson_result<std::string_view> escaped_key() noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> value() noexcept;\n};\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_FIELD_H\n/* end file simdjson/generic/ondemand/field.h for lasx */\n/* including simdjson/generic/ondemand/object.h for lasx: #include \"simdjson/generic/ondemand/object.h\" */\n/* begin file simdjson/generic/ondemand/object.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_OBJECT_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_OBJECT_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value_iterator.h\" */\n/* amalgamation skipped (editor-only): #include <vector> */\n/* amalgamation skipped (editor-only): #if SIMDJSON_STATIC_REFLECTION && SIMDJSON_SUPPORTS_CONCEPTS */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_string_builder.h\" // for constevalutil::fixed_string */\n/* amalgamation skipped (editor-only): #endif */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\n/**\n * A forward-only JSON object field iterator.\n */\nclass object {\npublic:\n /**\n * Create a new invalid object.\n *\n * Exists so you can declare a variable and later assign to it before use.\n */\n simdjson_inline object() noexcept = default;\n\n simdjson_inline simdjson_result<object_iterator> begin() noexcept;\n simdjson_inline simdjson_result<object_iterator> end() noexcept;\n /**\n * Look up a field by name on an object (order-sensitive).\n *\n * The following code reads z, then y, then x, and thus will not retrieve x or y if fed the\n * JSON `{ \"x\": 1, \"y\": 2, \"z\": 3 }`:\n *\n * ```cpp\n * simdjson::ondemand::parser parser;\n * auto obj = parser.parse(R\"( { \"x\": 1, \"y\": 2, \"z\": 3 } )\"_padded);\n * double z = obj.find_field(\"z\");\n * double y = obj.find_field(\"y\");\n * double x = obj.find_field(\"x\");\n * ```\n * If you have multiple fields with a matching key ({\"x\": 1, \"x\": 1}) be mindful\n * that only one field is returned.\n *\n * **Raw Keys:** The lookup will be done against the *raw* key, and will not unescape keys.\n * e.g. `object[\"a\"]` will match `{ \"a\": 1 }`, but will *not* match `{ \"\\u0061\": 1 }`.\n *\n * You must consume the fields on an object one at a time. A request for a new key\n * invalidates previous field values: it makes them unsafe. The value instance you get\n * from `content[\"bids\"]` becomes invalid when you call `content[\"asks\"]`. The array\n * given by content[\"bids\"].get_array() should not be accessed after you have called\n * content[\"asks\"].get_array(). You can detect such mistakes by first compiling and running\n * the code in Debug mode (or with the macro `SIMDJSON_DEVELOPMENT_CHECKS` set to 1): an\n * OUT_OF_ORDER_ITERATION error is generated.\n *\n * You are expected to access keys only once. You should access the value corresponding to a\n * key a single time. Doing object[\"mykey\"].to_string() and then again object[\"mykey\"].to_string()\n * is an error.\n *\n * If you expect to have keys with escape characters, please review our documentation.\n *\n * @param key The key to look up.\n * @returns The value of the field, or NO_SUCH_FIELD if the field is not in the object.\n */\n simdjson_inline simdjson_result<value> find_field(std::string_view key) & noexcept;\n /** @overload simdjson_inline simdjson_result<value> find_field(std::string_view key) & noexcept; */\n simdjson_inline simdjson_result<value> find_field(std::string_view key) && noexcept;\n\n /**\n * Look up a field by name on an object, without regard to key order.\n *\n * **Performance Notes:** This is a bit less performant than find_field(), though its effect varies\n * and often appears negligible. It starts out normally, starting out at the last field; but if\n * the field is not found, it scans from the beginning of the object to see if it missed it. That\n * missing case has a non-cache-friendly bump and lots of extra scanning, especially if the object\n * in question is large. The fact that the extra code is there also bumps the executable size.\n *\n * It is the default, however, because it would be highly surprising (and hard to debug) if the\n * default behavior failed to look up a field just because it was in the wrong order--and many\n * APIs assume this. Therefore, you must be explicit if you want to treat objects as out of order.\n *\n * Use find_field() if you are sure fields will be in order (or are willing to treat it as if the\n * field was not there when they are not in order).\n *\n * If you have multiple fields with a matching key ({\"x\": 1, \"x\": 1}) be mindful\n * that only one field is returned.\n *\n * You must consume the fields on an object one at a time. A request for a new key\n * invalidates previous field values: it makes them unsafe. The value instance you get\n * from `content[\"bids\"]` becomes invalid when you call `content[\"asks\"]`. The array\n * given by content[\"bids\"].get_array() should not be accessed after you have called\n * content[\"asks\"].get_array(). You can detect such mistakes by first compiling and running\n * the code in Debug mode (or with the macro `SIMDJSON_DEVELOPMENT_CHECKS` set to 1): an\n * OUT_OF_ORDER_ITERATION error is generated.\n *\n * You are expected to access keys only once. You should access the value corresponding to a key\n * a single time. Doing object[\"mykey\"].to_string() and then again object[\"mykey\"].to_string() is an error.\n *\n * If you expect to have keys with escape characters, please review our documentation.\n *\n * @param key The key to look up.\n * @returns The value of the field, or NO_SUCH_FIELD if the field is not in the object.\n */\n simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept;\n /** @overload simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept; */\n simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) && noexcept;\n /** @overload simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept; */\n simdjson_inline simdjson_result<value> operator[](std::string_view key) & noexcept;\n /** @overload simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept; */\n simdjson_inline simdjson_result<value> operator[](std::string_view key) && noexcept;\n\n /**\n * Get the value associated with the given JSON pointer. We use the RFC 6901\n * https://tools.ietf.org/html/rfc6901 standard, interpreting the current node\n * as the root of its own JSON document.\n *\n * ondemand::parser parser;\n * auto json = R\"({ \"foo\": { \"a\": [ 10, 20, 30 ] }})\"_padded;\n * auto doc = parser.iterate(json);\n * doc.at_pointer(\"/foo/a/1\") == 20\n *\n * It is allowed for a key to be the empty string:\n *\n * ondemand::parser parser;\n * auto json = R\"({ \"\": { \"a\": [ 10, 20, 30 ] }})\"_padded;\n * auto doc = parser.iterate(json);\n * doc.at_pointer(\"//a/1\") == 20\n *\n * Note that at_pointer() called on the document automatically calls the document's rewind\n * method between each call. It invalidates all previously accessed arrays, objects and values\n * that have not been consumed. Yet it is not the case when calling at_pointer on an object\n * instance: there is no rewind and no invalidation.\n *\n * You may call at_pointer more than once on an object, but each time the pointer is advanced\n * to be within the value matched by the key indicated by the JSON pointer query. Thus any preceding\n * key (as well as the current key) can no longer be used with following JSON pointer calls.\n *\n * Also note that at_pointer() relies on find_field() which implies that we do not unescape keys when matching.\n *\n * @return The value associated with the given JSON pointer, or:\n * - NO_SUCH_FIELD if a field does not exist in an object\n * - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length\n * - INCORRECT_TYPE if a non-integer is used to access an array\n * - INVALID_JSON_POINTER if the JSON pointer is invalid and cannot be parsed\n */\n inline simdjson_result<value> at_pointer(std::string_view json_pointer) noexcept;\n\n /**\n * Get the value associated with the given JSONPath expression. We only support\n * JSONPath queries that trivially convertible to JSON Pointer queries: key\n * names and array indices.\n *\n * @return The value associated with the given JSONPath expression, or:\n * - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails\n * - NO_SUCH_FIELD if a field does not exist in an object\n * - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length\n * - INCORRECT_TYPE if a non-integer is used to access an array\n */\n inline simdjson_result<value> at_path(std::string_view json_path) noexcept;\n\n /**\n * Get all values matching the given JSONPath expression with wildcard support.\n * Supports wildcard patterns like \".*\" to match all object fields.\n *\n * @param json_path JSONPath expression with wildcards\n * @return Vector of values matching the wildcard pattern\n */\n inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;\n\n /**\n * Reset the iterator so that we are pointing back at the\n * beginning of the object. You should still consume values only once even if you\n * can iterate through the object more than once. If you unescape a string or a key\n * within the object more than once, you have unsafe code. Note that rewinding an object\n * means that you may need to reparse it anew: it is not a free operation.\n *\n * @returns true if the object contains some elements (not empty)\n */\n inline simdjson_result<bool> reset() & noexcept;\n /**\n * This method scans the beginning of the object and checks whether the\n * object is empty.\n * The runtime complexity is constant time. After\n * calling this function, if successful, the object is 'rewinded' at its\n * beginning as if it had never been accessed. If the JSON is malformed (e.g.,\n * there is a missing comma), then an error is returned and it is no longer\n * safe to continue.\n */\n inline simdjson_result<bool> is_empty() & noexcept;\n /**\n * This method scans the object and counts the number of key-value pairs.\n * The count_fields method should always be called before you have begun\n * iterating through the object: it is expected that you are pointing at\n * the beginning of the object.\n * The runtime complexity is linear in the size of the object. After\n * calling this function, if successful, the object is 'rewinded' at its\n * beginning as if it had never been accessed. If the JSON is malformed (e.g.,\n * there is a missing comma), then an error is returned and it is no longer\n * safe to continue.\n *\n * To check that an object is empty, it is more performant to use\n * the is_empty() method.\n *\n * Performance hint: You should only call count_fields() as a last\n * resort as it may require scanning the document twice or more.\n */\n simdjson_inline simdjson_result<size_t> count_fields() & noexcept;\n /**\n * Consumes the object and returns a string_view instance corresponding to the\n * object as represented in JSON. It points inside the original byte array containing\n * the JSON document.\n */\n simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;\n\n#if SIMDJSON_SUPPORTS_CONCEPTS\n /**\n * Get this object as the given type.\n *\n * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.\n * @returns INCORRECT_TYPE If the JSON object is not of the given type.\n * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.\n */\n template <typename T>\n simdjson_warn_unused simdjson_inline error_code get(T &out)\n noexcept(custom_deserializable<T, object> ? nothrow_custom_deserializable<T, object> : true) {\n static_assert(custom_deserializable<T, object>);\n return deserialize(*this, out);\n }\n /**\n * Get this array as the given type.\n *\n * @returns A value of the given type, parsed from the JSON.\n * @returns INCORRECT_TYPE If the JSON value is not the given type.\n */\n template <typename T>\n simdjson_inline simdjson_result<T> get()\n noexcept(custom_deserializable<T, value> ? nothrow_custom_deserializable<T, value> : true)\n {\n static_assert(std::is_default_constructible<T>::value, \"The specified type is not default constructible.\");\n T out{};\n SIMDJSON_TRY(get<T>(out));\n return out;\n }\n\n#if SIMDJSON_STATIC_REFLECTION\n /**\n * Extract only specific fields from the JSON object into a struct.\n *\n * This allows selective deserialization of only the fields you need,\n * potentially improving performance by skipping unwanted fields.\n *\n * Example:\n * ```cpp\n * struct Car {\n * std::string make;\n * std::string model;\n * int year;\n * double price;\n * };\n *\n * Car car;\n * object.extract_into<\"make\", \"model\">(car);\n * // Only 'make' and 'model' fields are extracted from JSON\n * ```\n *\n * @tparam FieldNames Compile-time string literals specifying which fields to extract\n * @param out The output struct to populate with selected fields\n * @returns SUCCESS on success, or an error code if a required field is missing or has wrong type\n */\n template<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\n simdjson_warn_unused simdjson_inline error_code extract_into(T& out) & noexcept;\n#endif // SIMDJSON_STATIC_REFLECTION\n#endif // SIMDJSON_SUPPORTS_CONCEPTS\nprotected:\n /**\n * Go to the end of the object, no matter where you are right now.\n */\n simdjson_warn_unused simdjson_inline error_code consume() noexcept;\n static simdjson_inline simdjson_result<object> start(value_iterator &iter) noexcept;\n static simdjson_inline simdjson_result<object> start_root(value_iterator &iter) noexcept;\n static simdjson_inline simdjson_result<object> started(value_iterator &iter) noexcept;\n static simdjson_inline object resume(const value_iterator &iter) noexcept;\n simdjson_inline object(const value_iterator &iter) noexcept;\n\n simdjson_warn_unused simdjson_inline error_code find_field_raw(const std::string_view key) noexcept;\n\n value_iterator iter{};\n\n friend class value;\n friend class document;\n friend struct simdjson_result<object>;\n};\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\ntemplate<>\nstruct simdjson_result<lasx::ondemand::object> : public lasx::implementation_simdjson_result_base<lasx::ondemand::object> {\npublic:\n simdjson_inline simdjson_result(lasx::ondemand::object &&value) noexcept; ///< @private\n simdjson_inline simdjson_result(error_code error) noexcept; ///< @private\n simdjson_inline simdjson_result() noexcept = default;\n\n simdjson_inline simdjson_result<lasx::ondemand::object_iterator> begin() noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::object_iterator> end() noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> find_field(std::string_view key) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> find_field(std::string_view key) && noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> find_field_unordered(std::string_view key) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> find_field_unordered(std::string_view key) && noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> operator[](std::string_view key) & noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> operator[](std::string_view key) && noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;\n simdjson_inline simdjson_result<lasx::ondemand::value> at_path(std::string_view json_path) noexcept;\n simdjson_inline simdjson_result<std::vector<lasx::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;\n inline simdjson_result<bool> reset() noexcept;\n inline simdjson_result<bool> is_empty() noexcept;\n inline simdjson_result<size_t> count_fields() & noexcept;\n inline simdjson_result<std::string_view> raw_json() noexcept;\n #if SIMDJSON_SUPPORTS_CONCEPTS\n // TODO: move this code into object-inl.h\n\n template<typename T>\n simdjson_inline simdjson_result<T> get() noexcept {\n if (error()) { return error(); }\n if constexpr (std::is_same_v<T, lasx::ondemand::object>) {\n return first;\n }\n return first.get<T>();\n }\n template<typename T>\n simdjson_warn_unused simdjson_inline error_code get(T& out) noexcept {\n if (error()) { return error(); }\n if constexpr (std::is_same_v<T, lasx::ondemand::object>) {\n out = first;\n } else {\n SIMDJSON_TRY( first.get<T>(out) );\n }\n return SUCCESS;\n }\n\n#if SIMDJSON_STATIC_REFLECTION\n // TODO: move this code into object-inl.h\n template<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\n simdjson_warn_unused simdjson_inline error_code extract_into(T& out) noexcept {\n if (error()) { return error(); }\n return first.extract_into<FieldNames...>(out);\n }\n#endif // SIMDJSON_STATIC_REFLECTION\n#endif // SIMDJSON_SUPPORTS_CONCEPTS\n};\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_H\n/* end file simdjson/generic/ondemand/object.h for lasx */\n/* including simdjson/generic/ondemand/object_iterator.h for lasx: #include \"simdjson/generic/ondemand/object_iterator.h\" */\n/* begin file simdjson/generic/ondemand/object_iterator.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value_iterator.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\nclass object_iterator {\npublic:\n /**\n * Create a new invalid object_iterator.\n *\n * Exists so you can declare a variable and later assign to it before use.\n */\n simdjson_inline object_iterator() noexcept = default;\n\n //\n // Iterator interface\n //\n\n // Reads key and value, yielding them to the user.\n // MUST ONLY BE CALLED ONCE PER ITERATION.\n simdjson_inline simdjson_result<field> operator*() noexcept;\n // Assumes it's being compared with the end. true if depth < iter->depth.\n simdjson_inline bool operator==(const object_iterator &) const noexcept;\n // Assumes it's being compared with the end. true if depth >= iter->depth.\n simdjson_inline bool operator!=(const object_iterator &) const noexcept;\n // Checks for ']' and ','\n simdjson_inline object_iterator &operator++() noexcept;\n\nprivate:\n /**\n * The underlying JSON iterator.\n *\n * PERF NOTE: expected to be elided in favor of the parent document: this is set when the object\n * is first used, and never changes afterwards.\n */\n value_iterator iter{};\n\n simdjson_inline object_iterator(const value_iterator &iter) noexcept;\n friend struct simdjson_result<object_iterator>;\n friend class object;\n};\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\ntemplate<>\nstruct simdjson_result<lasx::ondemand::object_iterator> : public lasx::implementation_simdjson_result_base<lasx::ondemand::object_iterator> {\npublic:\n simdjson_inline simdjson_result(lasx::ondemand::object_iterator &&value) noexcept; ///< @private\n simdjson_inline simdjson_result(error_code error) noexcept; ///< @private\n simdjson_inline simdjson_result() noexcept = default;\n\n //\n // Iterator interface\n //\n\n // Reads key and value, yielding them to the user.\n simdjson_inline simdjson_result<lasx::ondemand::field> operator*() noexcept; // MUST ONLY BE CALLED ONCE PER ITERATION.\n // Assumes it's being compared with the end. true if depth < iter->depth.\n simdjson_inline bool operator==(const simdjson_result<lasx::ondemand::object_iterator> &) const noexcept;\n // Assumes it's being compared with the end. true if depth >= iter->depth.\n simdjson_inline bool operator!=(const simdjson_result<lasx::ondemand::object_iterator> &) const noexcept;\n // Checks for ']' and ','\n simdjson_inline simdjson_result<lasx::ondemand::object_iterator> &operator++() noexcept;\n};\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_H\n/* end file simdjson/generic/ondemand/object_iterator.h for lasx */\n/* including simdjson/generic/ondemand/serialization.h for lasx: #include \"simdjson/generic/ondemand/serialization.h\" */\n/* begin file simdjson/generic/ondemand/serialization.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\n/**\n * Create a string-view instance out of a document instance. The string-view instance\n * contains JSON text that is suitable to be parsed as JSON again. It does not\n * validate the content.\n */\ninline simdjson_result<std::string_view> to_json_string(lasx::ondemand::document& x) noexcept;\n/**\n * Create a string-view instance out of a value instance. The string-view instance\n * contains JSON text that is suitable to be parsed as JSON again. The value must\n * not have been accessed previously. It does not\n * validate the content.\n */\ninline simdjson_result<std::string_view> to_json_string(lasx::ondemand::value& x) noexcept;\n/**\n * Create a string-view instance out of an object instance. The string-view instance\n * contains JSON text that is suitable to be parsed as JSON again. It does not\n * validate the content.\n */\ninline simdjson_result<std::string_view> to_json_string(lasx::ondemand::object& x) noexcept;\n/**\n * Create a string-view instance out of an array instance. The string-view instance\n * contains JSON text that is suitable to be parsed as JSON again. It does not\n * validate the content.\n */\ninline simdjson_result<std::string_view> to_json_string(lasx::ondemand::array& x) noexcept;\ninline simdjson_result<std::string_view> to_json_string(simdjson_result<lasx::ondemand::document> x);\ninline simdjson_result<std::string_view> to_json_string(simdjson_result<lasx::ondemand::value> x);\ninline simdjson_result<std::string_view> to_json_string(simdjson_result<lasx::ondemand::object> x);\ninline simdjson_result<std::string_view> to_json_string(simdjson_result<lasx::ondemand::array> x);\n\n#if SIMDJSON_STATIC_REFLECTION\n/**\n * Create a JSON string from any user-defined type using static reflection.\n * Only available when SIMDJSON_STATIC_REFLECTION is enabled.\n */\ntemplate<typename T>\n requires(!std::same_as<T, lasx::ondemand::document> &&\n !std::same_as<T, lasx::ondemand::value> &&\n !std::same_as<T, lasx::ondemand::object> &&\n !std::same_as<T, lasx::ondemand::array>)\ninline std::string to_json_string(const T& obj);\n#endif\n\n} // namespace simdjson\n\n/**\n * We want to support argument-dependent lookup (ADL).\n * Hence we should define operator<< in the namespace\n * where the argument (here value, object, etc.) resides.\n * Credit: @madhur4127\n * See https://github.com/simdjson/simdjson/issues/1768\n */\nnamespace simdjson { namespace lasx { namespace ondemand {\n\n/**\n * Print JSON to an output stream. It does not\n * validate the content.\n *\n * @param out The output stream.\n * @param value The element.\n * @throw if there is an error with the underlying output stream. simdjson itself will not throw.\n */\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::value x);\n#if SIMDJSON_EXCEPTIONS\ninline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lasx::ondemand::value> x);\n#endif\n/**\n * Print JSON to an output stream. It does not\n * validate the content.\n *\n * @param out The output stream.\n * @param value The array.\n * @throw if there is an error with the underlying output stream. simdjson itself will not throw.\n */\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::array value);\n#if SIMDJSON_EXCEPTIONS\ninline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lasx::ondemand::array> x);\n#endif\n/**\n * Print JSON to an output stream. It does not\n * validate the content.\n *\n * @param out The output stream.\n * @param value The array.\n * @throw if there is an error with the underlying output stream. simdjson itself will not throw.\n */\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::document& value);\n#if SIMDJSON_EXCEPTIONS\ninline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lasx::ondemand::document>&& x);\n#endif\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::document_reference& value);\n#if SIMDJSON_EXCEPTIONS\ninline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lasx::ondemand::document_reference>&& x);\n#endif\n/**\n * Print JSON to an output stream. It does not\n * validate the content.\n *\n * @param out The output stream.\n * @param value The object.\n * @throw if there is an error with the underlying output stream. simdjson itself will not throw.\n */\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::object value);\n#if SIMDJSON_EXCEPTIONS\ninline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lasx::ondemand::object> x);\n#endif\n}}} // namespace simdjson::lasx::ondemand\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_H\n/* end file simdjson/generic/ondemand/serialization.h for lasx */\n\n// Deserialization for standard types\n/* including simdjson/generic/ondemand/std_deserialize.h for lasx: #include \"simdjson/generic/ondemand/std_deserialize.h\" */\n/* begin file simdjson/generic/ondemand/std_deserialize.h for lasx */\n#if SIMDJSON_SUPPORTS_CONCEPTS\n\n#ifndef SIMDJSON_ONDEMAND_DESERIALIZE_H\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_ONDEMAND_DESERIALIZE_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/object.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/array.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\n#include <concepts>\n#include <limits>\n#if SIMDJSON_STATIC_REFLECTION\n#include <meta>\n// #include <static_reflection> // for std::define_static_string - header not available yet\n#endif\n\nnamespace simdjson {\n\n//////////////////////////////\n// Number deserialization\n//////////////////////////////\n\ntemplate <std::unsigned_integral T>\nerror_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {\n using limits = std::numeric_limits<T>;\n\n uint64_t x;\n SIMDJSON_TRY(val.get_uint64().get(x));\n if (x > (limits::max)()) {\n return NUMBER_OUT_OF_RANGE;\n }\n out = static_cast<T>(x);\n return SUCCESS;\n}\n\ntemplate <std::floating_point T>\nerror_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {\n double x;\n SIMDJSON_TRY(val.get_double().get(x));\n out = static_cast<T>(x);\n return SUCCESS;\n}\n\ntemplate <std::signed_integral T>\nerror_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {\n using limits = std::numeric_limits<T>;\n\n int64_t x;\n SIMDJSON_TRY(val.get_int64().get(x));\n if (x > (limits::max)() || x < (limits::min)()) {\n return NUMBER_OUT_OF_RANGE;\n }\n out = static_cast<T>(x);\n return SUCCESS;\n}\n\n//////////////////////////////\n// String deserialization\n//////////////////////////////\n\n// just a character!\nerror_code tag_invoke(deserialize_tag, auto &val, char &out) noexcept {\n std::string_view x;\n SIMDJSON_TRY(val.get_string().get(x));\n if(x.size() != 1) {\n return INCORRECT_TYPE;\n }\n out = x[0];\n return SUCCESS;\n}\n\n// any string-like type (can be constructed from std::string_view)\ntemplate <concepts::constructible_from_string_view T, typename ValT>\nerror_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(std::is_nothrow_constructible_v<T, std::string_view>) {\n std::string_view str;\n SIMDJSON_TRY(val.get_string().get(str));\n out = T{str};\n return SUCCESS;\n}\n\n\n/**\n * STL containers have several constructors including one that takes a single\n * size argument. Thus, some compilers (Visual Studio) will not be able to\n * disambiguate between the size and container constructor. Users should\n * explicitly specify the type of the container as needed: e.g.,\n * doc.get<std::vector<int>>().\n */\ntemplate <concepts::appendable_containers T, typename ValT>\nerror_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(false) {\n using value_type = typename std::remove_cvref_t<T>::value_type;\n static_assert(\n deserializable<value_type, ValT>,\n \"The specified type inside the container must itself be deserializable\");\n static_assert(\n std::is_default_constructible_v<value_type>,\n \"The specified type inside the container must default constructible.\");\n lasx::ondemand::array arr;\n if constexpr (std::is_same_v<std::remove_cvref_t<ValT>, lasx::ondemand::array>) {\n arr = val;\n } else {\n SIMDJSON_TRY(val.get_array().get(arr));\n }\n\n for (auto v : arr) {\n if constexpr (concepts::returns_reference<T>) {\n if (auto const err = v.get<value_type>().get(concepts::emplace_one(out));\n err) {\n // If an error occurs, the empty element that we just inserted gets\n // removed. We're not using a temp variable because if T is a heavy\n // type, we want the valid path to be the fast path and the slow path be\n // the path that has errors in it.\n if constexpr (requires { out.pop_back(); }) {\n static_cast<void>(out.pop_back());\n }\n return err;\n }\n } else {\n value_type temp;\n if (auto const err = v.get<value_type>().get(temp); err) {\n return err;\n }\n concepts::emplace_one(out, std::move(temp));\n }\n }\n return SUCCESS;\n}\n\n\n/**\n * We want to support std::map and std::unordered_map but only for\n * string-keyed types.\n */\n template <concepts::string_view_keyed_map T, typename ValT>\nerror_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(false) {\n using value_type = typename std::remove_cvref_t<T>::mapped_type;\n static_assert(\n deserializable<value_type, ValT>,\n \"The specified value type inside the container must itself be deserializable\");\n static_assert(\n std::is_default_constructible_v<value_type>,\n \"The specified value type inside the container must default constructible.\");\n lasx::ondemand::object obj;\n SIMDJSON_TRY(val.get_object().get(obj));\n for (auto field : obj) {\n std::string_view key;\n SIMDJSON_TRY(field.unescaped_key().get(key));\n value_type this_value;\n SIMDJSON_TRY(field.value().get<value_type>().get(this_value));\n [[maybe_unused]] std::pair<typename T::iterator, bool> result = out.emplace(key, this_value);\n // unclear what to do if the key already exists\n // if (result.second == false) {\n // // key already exists\n // }\n }\n (void)out;\n return SUCCESS;\n}\n\ntemplate <concepts::string_view_keyed_map T>\nerror_code tag_invoke(deserialize_tag, lasx::ondemand::object &obj, T &out) noexcept {\n using value_type = typename std::remove_cvref_t<T>::mapped_type;\n\n out.clear();\n for (auto field : obj) {\n std::string_view key;\n SIMDJSON_TRY(field.unescaped_key().get(key));\n\n lasx::ondemand::value value_obj;\n SIMDJSON_TRY(field.value().get(value_obj));\n\n value_type this_value;\n SIMDJSON_TRY(value_obj.get(this_value));\n out.emplace(typename T::key_type(key), std::move(this_value));\n }\n return SUCCESS;\n}\n\ntemplate <concepts::string_view_keyed_map T>\nerror_code tag_invoke(deserialize_tag, lasx::ondemand::value &val, T &out) noexcept {\n lasx::ondemand::object obj;\n SIMDJSON_TRY(val.get_object().get(obj));\n return simdjson::deserialize(obj, out);\n}\n\ntemplate <concepts::string_view_keyed_map T>\nerror_code tag_invoke(deserialize_tag, lasx::ondemand::document &doc, T &out) noexcept {\n lasx::ondemand::object obj;\n SIMDJSON_TRY(doc.get_object().get(obj));\n return simdjson::deserialize(obj, out);\n}\n\ntemplate <concepts::string_view_keyed_map T>\nerror_code tag_invoke(deserialize_tag, lasx::ondemand::document_reference &doc, T &out) noexcept {\n lasx::ondemand::object obj;\n SIMDJSON_TRY(doc.get_object().get(obj));\n return simdjson::deserialize(obj, out);\n}\n\n\n/**\n * This CPO (Customization Point Object) will help deserialize into\n * smart pointers.\n *\n * If constructing T is nothrow, this conversion should be nothrow as well since\n * we return MEMALLOC if we're not able to allocate memory instead of throwing\n * the error message.\n *\n * @tparam T The type inside the smart pointer\n * @tparam ValT document/value type\n * @param val document/value\n * @param out a reference to the smart pointer\n * @return status of the conversion\n */\ntemplate <concepts::smart_pointer T, typename ValT>\nerror_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(nothrow_deserializable<typename std::remove_cvref_t<T>::element_type, ValT>) {\n using element_type = typename std::remove_cvref_t<T>::element_type;\n\n // For better error messages, don't use these as constraints on\n // the tag_invoke CPO.\n static_assert(\n deserializable<element_type, ValT>,\n \"The specified type inside the unique_ptr must itself be deserializable\");\n static_assert(\n std::is_default_constructible_v<element_type>,\n \"The specified type inside the unique_ptr must default constructible.\");\n\n auto ptr = new (std::nothrow) element_type();\n if (ptr == nullptr) {\n return MEMALLOC;\n }\n SIMDJSON_TRY(val.template get<element_type>(*ptr));\n out.reset(ptr);\n return SUCCESS;\n}\n\n/**\n * This CPO (Customization Point Object) will help deserialize into optional types.\n */\ntemplate <concepts::optional_type T>\nerror_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept(nothrow_deserializable<typename std::remove_cvref_t<T>::value_type, decltype(val)>) {\n using value_type = typename std::remove_cvref_t<T>::value_type;\n\n // Check if the value is null\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset(); // Set to nullopt\n return SUCCESS;\n }\n\n if (!out) {\n out.emplace();\n }\n SIMDJSON_TRY(val.template get<value_type>(out.value()));\n return SUCCESS;\n}\n\n\n#if SIMDJSON_STATIC_REFLECTION\n\n\ntemplate <typename T>\nconstexpr bool user_defined_type = (std::is_class_v<T>\n&& !std::is_same_v<T, std::string> && !std::is_same_v<T, std::string_view> && !concepts::optional_type<T> &&\n!concepts::appendable_containers<T>);\n\n\ntemplate <typename T, typename ValT>\n requires(user_defined_type<T> && std::is_class_v<T>)\nerror_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {\n lasx::ondemand::object obj;\n if constexpr (std::is_same_v<std::remove_cvref_t<ValT>, lasx::ondemand::object>) {\n obj = val;\n } else {\n SIMDJSON_TRY(val.get_object().get(obj));\n }\n template for (constexpr auto mem : std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {\n if constexpr (!std::meta::is_const(mem) && std::meta::is_public(mem)) {\n constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));\n if constexpr (concepts::optional_type<decltype(out.[:mem:])>) {\n // for optional members, it's ok if the key is missing\n auto error = obj[key].get(out.[:mem:]);\n if (error && error != NO_SUCH_FIELD) {\n if(error == NO_SUCH_FIELD) {\n out.[:mem:].reset();\n continue;\n }\n return error;\n }\n } else {\n // for non-optional members, the key must be present\n SIMDJSON_TRY(obj[key].get(out.[:mem:]));\n }\n }\n };\n return simdjson::SUCCESS;\n}\n\n// Support for enum deserialization - deserialize from string representation using expand approach from P2996R12\ntemplate <typename T, typename ValT>\n requires(std::is_enum_v<T>)\nerror_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {\n#if SIMDJSON_STATIC_REFLECTION\n std::string_view str;\n SIMDJSON_TRY(val.get_string().get(str));\n constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));\n template for (constexpr auto enum_val : enumerators) {\n if (str == std::meta::identifier_of(enum_val)) {\n out = [:enum_val:];\n return SUCCESS;\n }\n };\n\n return INCORRECT_TYPE;\n#else\n // Fallback: deserialize as integer if reflection not available\n std::underlying_type_t<T> int_val;\n SIMDJSON_TRY(val.get(int_val));\n out = static_cast<T>(int_val);\n return SUCCESS;\n#endif\n}\n\ntemplate <typename simdjson_value, typename T>\n requires(user_defined_type<std::remove_cvref_t<T>>)\nerror_code tag_invoke(deserialize_tag, simdjson_value &val, std::unique_ptr<T> &out) noexcept {\n if (!out) {\n out = std::make_unique<T>();\n if (!out) {\n return MEMALLOC;\n }\n }\n if (auto err = val.get(*out)) {\n out.reset();\n return err;\n }\n return SUCCESS;\n}\n\ntemplate <typename simdjson_value, typename T>\n requires(user_defined_type<std::remove_cvref_t<T>>)\nerror_code tag_invoke(deserialize_tag, simdjson_value &val, std::shared_ptr<T> &out) noexcept {\n if (!out) {\n out = std::make_shared<T>();\n if (!out) {\n return MEMALLOC;\n }\n }\n if (auto err = val.get(*out)) {\n out.reset();\n return err;\n }\n return SUCCESS;\n}\n\n#endif // SIMDJSON_STATIC_REFLECTION\n\n////////////////////////////////////////\n// Unique pointers\n////////////////////////////////////////\nerror_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<bool> &out) noexcept {\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset();\n return SUCCESS;\n }\n if (!out) {\n out = std::make_unique<bool>();\n if (!out) { return MEMALLOC; }\n }\n SIMDJSON_TRY(val.get_bool().get(*out));\n return SUCCESS;\n}\n\nerror_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<int64_t> &out) noexcept {\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset();\n return SUCCESS;\n }\n if (!out) {\n out = std::make_unique<int64_t>();\n if (!out) { return MEMALLOC; }\n }\n SIMDJSON_TRY(val.get_int64().get(*out));\n return SUCCESS;\n}\n\nerror_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<uint64_t> &out) noexcept {\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset();\n return SUCCESS;\n }\n if (!out) {\n out = std::make_unique<uint64_t>();\n if (!out) { return MEMALLOC; }\n }\n SIMDJSON_TRY(val.get_uint64().get(*out));\n return SUCCESS;\n}\n\nerror_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<double> &out) noexcept {\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset();\n return SUCCESS;\n }\n if (!out) {\n out = std::make_unique<double>();\n if (!out) { return MEMALLOC; }\n }\n SIMDJSON_TRY(val.get_double().get(*out));\n return SUCCESS;\n}\n\nerror_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<std::string_view> &out) noexcept {\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset();\n return SUCCESS;\n }\n if (!out) {\n out = std::make_unique<std::string_view>();\n if (!out) { return MEMALLOC; }\n }\n SIMDJSON_TRY(val.get_string().get(*out));\n return SUCCESS;\n}\n\n\n////////////////////////////////////////\n// Shared pointers\n////////////////////////////////////////\nerror_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<bool> &out) noexcept {\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset();\n return SUCCESS;\n }\n if (!out) {\n out = std::make_shared<bool>();\n if (!out) { return MEMALLOC; }\n }\n SIMDJSON_TRY(val.get_bool().get(*out));\n return SUCCESS;\n}\n\nerror_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<int64_t> &out) noexcept {\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset();\n return SUCCESS;\n }\n if (!out) {\n out = std::make_shared<int64_t>();\n if (!out) { return MEMALLOC; }\n }\n SIMDJSON_TRY(val.get_int64().get(*out));\n return SUCCESS;\n}\n\nerror_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<uint64_t> &out) noexcept {\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset();\n return SUCCESS;\n }\n if (!out) {\n out = std::make_shared<uint64_t>();\n if (!out) { return MEMALLOC; }\n }\n SIMDJSON_TRY(val.get_uint64().get(*out));\n return SUCCESS;\n}\n\nerror_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<double> &out) noexcept {\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset();\n return SUCCESS;\n }\n if (!out) {\n out = std::make_shared<double>();\n if (!out) { return MEMALLOC; }\n }\n SIMDJSON_TRY(val.get_double().get(*out));\n return SUCCESS;\n}\n\nerror_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<std::string_view> &out) noexcept {\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset();\n return SUCCESS;\n }\n if (!out) {\n out = std::make_shared<std::string_view>();\n if (!out) { return MEMALLOC; }\n }\n SIMDJSON_TRY(val.get_string().get(*out));\n return SUCCESS;\n}\n\n\n////////////////////////////////////////\n// Explicit optional specializations\n////////////////////////////////////////\n\n////////////////////////////////////////\n// Explicit smart pointer specializations for string and int types\n////////////////////////////////////////\nerror_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<std::string> &out) noexcept {\n // Check if the value is null\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset(); // Set to nullptr\n return SUCCESS;\n }\n\n if (!out) {\n out = std::make_unique<std::string>();\n }\n std::string_view str;\n SIMDJSON_TRY(val.get_string().get(str));\n *out = std::string{str};\n return SUCCESS;\n}\n\nerror_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<std::string> &out) noexcept {\n // Check if the value is null\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset(); // Set to nullptr\n return SUCCESS;\n }\n\n if (!out) {\n out = std::make_shared<std::string>();\n }\n std::string_view str;\n SIMDJSON_TRY(val.get_string().get(str));\n *out = std::string{str};\n return SUCCESS;\n}\n\nerror_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<int> &out) noexcept {\n // Check if the value is null\n bool is_null_value;\n SIMDJSON_TRY( val.is_null().get(is_null_value) );\n if (is_null_value) {\n out.reset(); // Set to nullptr\n return SUCCESS;\n }\n\n if (!out) {\n out = std::make_unique<int>();\n }\n int64_t temp;\n SIMDJSON_TRY(val.get_int64().get(temp));\n *out = static_cast<int>(temp);\n return SUCCESS;\n}\n\n} // namespace simdjson\n\n#endif // SIMDJSON_ONDEMAND_DESERIALIZE_H\n#endif // SIMDJSON_SUPPORTS_CONCEPTS\n/* end file simdjson/generic/ondemand/std_deserialize.h for lasx */\n\n// Inline definitions\n/* including simdjson/generic/ondemand/array-inl.h for lasx: #include \"simdjson/generic/ondemand/array-inl.h\" */\n/* begin file simdjson/generic/ondemand/array-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_ARRAY_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_ARRAY_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/jsonpathutil.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/array.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/array_iterator-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value_iterator-inl.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\n//\n// ### Live States\n//\n// While iterating or looking up values, depth >= iter->depth. at_start may vary. Error is\n// always SUCCESS:\n//\n// - Start: This is the state when the array is first found and the iterator is just past the `{`.\n// In this state, at_start == true.\n// - Next: After we hand a scalar value to the user, or an array/object which they then fully\n// iterate over, the iterator is at the `,` before the next value (or `]`). In this state,\n// depth == iter->depth, at_start == false, and error == SUCCESS.\n// - Unfinished Business: When we hand an array/object to the user which they do not fully\n// iterate over, we need to finish that iteration by skipping child values until we reach the\n// Next state. In this state, depth > iter->depth, at_start == false, and error == SUCCESS.\n//\n// ## Error States\n//\n// In error states, we will yield exactly one more value before stopping. iter->depth == depth\n// and at_start is always false. We decrement after yielding the error, moving to the Finished\n// state.\n//\n// - Chained Error: When the array iterator is part of an error chain--for example, in\n// `for (auto tweet : doc[\"tweets\"])`, where the tweet element may be missing or not be an\n// array--we yield that error in the loop, exactly once. In this state, error != SUCCESS and\n// iter->depth == depth, and at_start == false. We decrement depth when we yield the error.\n// - Missing Comma Error: When the iterator ++ method discovers there is no comma between elements,\n// we flag that as an error and treat it exactly the same as a Chained Error. In this state,\n// error == TAPE_ERROR, iter->depth == depth, and at_start == false.\n//\n// ## Terminal State\n//\n// The terminal state has iter->depth < depth. at_start is always false.\n//\n// - Finished: When we have reached a `]` or have reported an error, we are finished. We signal this\n// by decrementing depth. In this state, iter->depth < depth, at_start == false, and\n// error == SUCCESS.\n//\n\nsimdjson_inline array::array(const value_iterator &_iter) noexcept\n : iter{_iter}\n{\n}\n\nsimdjson_inline simdjson_result<array> array::start(value_iterator &iter) noexcept {\n // We don't need to know if the array is empty to start iteration, but we do want to know if there\n // is an error--thus `simdjson_unused`.\n simdjson_unused bool has_value;\n SIMDJSON_TRY( iter.start_array().get(has_value) );\n return array(iter);\n}\nsimdjson_inline simdjson_result<array> array::start_root(value_iterator &iter) noexcept {\n simdjson_unused bool has_value;\n SIMDJSON_TRY( iter.start_root_array().get(has_value) );\n return array(iter);\n}\nsimdjson_inline simdjson_result<array> array::started(value_iterator &iter) noexcept {\n bool has_value;\n SIMDJSON_TRY(iter.started_array().get(has_value));\n return array(iter);\n}\n\nsimdjson_inline simdjson_result<array_iterator> array::begin() noexcept {\n#if SIMDJSON_DEVELOPMENT_CHECKS\n if (!iter.is_at_iterator_start()) { return OUT_OF_ORDER_ITERATION; }\n#endif\n return array_iterator(iter);\n}\nsimdjson_inline simdjson_result<array_iterator> array::end() noexcept {\n return array_iterator(iter);\n}\nsimdjson_warn_unused simdjson_warn_unused simdjson_inline error_code array::consume() noexcept {\n auto error = iter.json_iter().skip_child(iter.depth()-1);\n if(error) { iter.abandon(); }\n return error;\n}\n\nsimdjson_inline simdjson_result<std::string_view> array::raw_json() noexcept {\n const uint8_t * starting_point{iter.peek_start()};\n auto error = consume();\n if(error) { return error; }\n // After 'consume()', we could be left pointing just beyond the document, but that\n // is ok because we are not going to dereference the final pointer position, we just\n // use it to compute the length in bytes.\n const uint8_t * final_point{iter._json_iter->unsafe_pointer()};\n return std::string_view(reinterpret_cast<const char*>(starting_point), size_t(final_point - starting_point));\n}\n\nSIMDJSON_PUSH_DISABLE_WARNINGS\nSIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING\nsimdjson_inline simdjson_result<size_t> array::count_elements() & noexcept {\n size_t count{0};\n // Important: we do not consume any of the values.\n for(simdjson_unused auto v : *this) { count++; }\n // The above loop will always succeed, but we want to report errors.\n if(iter.error()) { return iter.error(); }\n // We need to move back at the start because we expect users to iterate through\n // the array after counting the number of elements.\n iter.reset_array();\n return count;\n}\nSIMDJSON_POP_DISABLE_WARNINGS\n\nsimdjson_inline simdjson_result<bool> array::is_empty() & noexcept {\n bool is_not_empty;\n auto error = iter.reset_array().get(is_not_empty);\n if(error) { return error; }\n return !is_not_empty;\n}\n\ninline simdjson_result<bool> array::reset() & noexcept {\n return iter.reset_array();\n}\n\ninline simdjson_result<value> array::at_pointer(std::string_view json_pointer) noexcept {\n if (json_pointer[0] != '/') { return INVALID_JSON_POINTER; }\n json_pointer = json_pointer.substr(1);\n // - means \"the append position\" or \"the element after the end of the array\"\n // We don't support this, because we're returning a real element, not a position.\n if (json_pointer == \"-\") { return INDEX_OUT_OF_BOUNDS; }\n\n // Read the array index\n size_t array_index = 0;\n size_t i;\n for (i = 0; i < json_pointer.length() && json_pointer[i] != '/'; i++) {\n uint8_t digit = uint8_t(json_pointer[i] - '0');\n // Check for non-digit in array index. If it's there, we're trying to get a field in an object\n if (digit > 9) { return INCORRECT_TYPE; }\n array_index = array_index*10 + digit;\n }\n\n // 0 followed by other digits is invalid\n if (i > 1 && json_pointer[0] == '0') { return INVALID_JSON_POINTER; } // \"JSON pointer array index has other characters after 0\"\n\n // Empty string is invalid; so is a \"/\" with no digits before it\n if (i == 0) { return INVALID_JSON_POINTER; } // \"Empty string in JSON pointer array index\"\n // Get the child\n auto child = at(array_index);\n // If there is an error, it ends here\n if(child.error()) {\n return child;\n }\n\n // If there is a /, we're not done yet, call recursively.\n if (i < json_pointer.length()) {\n child = child.at_pointer(json_pointer.substr(i));\n }\n return child;\n}\n\ninline simdjson_result<value> array::at_path(std::string_view json_path) noexcept {\n auto json_pointer = json_path_to_pointer_conversion(json_path);\n if (json_pointer == \"-1\") { return INVALID_JSON_POINTER; }\n return at_pointer(json_pointer);\n}\n\ninline simdjson_result<std::vector<value>> array::at_path_with_wildcard(std::string_view json_path) noexcept {\n std::vector<value> result;\n\n auto result_pair = get_next_key_and_json_path(json_path);\n std::string_view key = result_pair.first;\n std::string_view remaining_path = result_pair.second;\n // Wildcard case\n if(key==\"*\"){\n for(auto element: *this){\n\n if(element.error()){\n return element.error();\n }\n\n if(remaining_path.empty()){\n // Use value_unsafe() because we've already checked for errors above.\n // The 'element' is a simdjson_result<value> wrapper, and we need to extract\n // the underlying value. value_unsafe() is safe here because error() returned false.\n result.push_back(std::move(element).value_unsafe());\n\n }else{\n auto nested_result = element.at_path_with_wildcard(remaining_path);\n\n if(nested_result.error()){\n return nested_result.error();\n }\n // Same logic as above.\n std::vector<value> nested_matches = std::move(nested_result).value_unsafe();\n\n result.insert(result.end(),\n std::make_move_iterator(nested_matches.begin()),\n std::make_move_iterator(nested_matches.end()));\n }\n }\n return result;\n }else{\n // Specific index case in which we access the element at the given index\n size_t idx=0;\n\n for(char c:key){\n if(c < '0' || c > '9'){\n return INVALID_JSON_POINTER;\n }\n idx = idx*10 + (c - '0');\n }\n\n auto element = at(idx);\n\n if(element.error()){\n return element.error();\n }\n\n if(remaining_path.empty()){\n result.push_back(std::move(element).value_unsafe());\n return result;\n }else{\n return element.at_path_with_wildcard(remaining_path);\n }\n }\n}\n\nsimdjson_inline simdjson_result<value> array::at(size_t index) noexcept {\n size_t i = 0;\n for (auto value : *this) {\n if (i == index) { return value; }\n i++;\n }\n return INDEX_OUT_OF_BOUNDS;\n}\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::array>::simdjson_result(\n lasx::ondemand::array &&value\n) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::array>(\n std::forward<lasx::ondemand::array>(value)\n )\n{\n}\nsimdjson_inline simdjson_result<lasx::ondemand::array>::simdjson_result(\n error_code error\n) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::array>(error)\n{\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::array_iterator> simdjson_result<lasx::ondemand::array>::begin() noexcept {\n if (error()) { return error(); }\n return first.begin();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::array_iterator> simdjson_result<lasx::ondemand::array>::end() noexcept {\n if (error()) { return error(); }\n return first.end();\n}\nsimdjson_inline simdjson_result<size_t> simdjson_result<lasx::ondemand::array>::count_elements() & noexcept {\n if (error()) { return error(); }\n return first.count_elements();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::array>::is_empty() & noexcept {\n if (error()) { return error(); }\n return first.is_empty();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::array>::at(size_t index) noexcept {\n if (error()) { return error(); }\n return first.at(index);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::array>::at_pointer(std::string_view json_pointer) noexcept {\n if (error()) { return error(); }\n return first.at_pointer(json_pointer);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::array>::at_path(std::string_view json_path) noexcept {\n if (error()) { return error(); }\n return first.at_path(json_path);\n}\nsimdjson_inline simdjson_result<std::vector<lasx::ondemand::value>> simdjson_result<lasx::ondemand::array>::at_path_with_wildcard(std::string_view json_path) noexcept {\n if (error()) { return error(); }\n return first.at_path_with_wildcard(json_path);\n}\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::array>::raw_json() noexcept {\n if (error()) { return error(); }\n return first.raw_json();\n}\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_ARRAY_INL_H\n/* end file simdjson/generic/ondemand/array-inl.h for lasx */\n/* including simdjson/generic/ondemand/array_iterator-inl.h for lasx: #include \"simdjson/generic/ondemand/array_iterator-inl.h\" */\n/* begin file simdjson/generic/ondemand/array_iterator-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/array_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value_iterator-inl.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\nsimdjson_inline array_iterator::array_iterator(const value_iterator &_iter) noexcept\n : iter{_iter}\n{}\n\nsimdjson_inline simdjson_result<value> array_iterator::operator*() noexcept {\n if (iter.error()) { iter.abandon(); return iter.error(); }\n return value(iter.child());\n}\nsimdjson_inline bool array_iterator::operator==(const array_iterator &other) const noexcept {\n return !(*this != other);\n}\nsimdjson_inline bool array_iterator::operator!=(const array_iterator &) const noexcept {\n return iter.is_open();\n}\nsimdjson_inline array_iterator &array_iterator::operator++() noexcept {\n error_code error;\n // PERF NOTE this is a safety rail ... users should exit loops as soon as they receive an error, so we'll never get here.\n // However, it does not seem to make a perf difference, so we add it out of an abundance of caution.\n if (( error = iter.error() )) { return *this; }\n if (( error = iter.skip_child() )) { return *this; }\n if (( error = iter.has_next_element().error() )) { return *this; }\n return *this;\n}\n\nsimdjson_inline bool array_iterator::at_end() const noexcept {\n return iter.at_end();\n}\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::array_iterator>::simdjson_result(\n lasx::ondemand::array_iterator &&value\n) noexcept\n : lasx::implementation_simdjson_result_base<lasx::ondemand::array_iterator>(std::forward<lasx::ondemand::array_iterator>(value))\n{\n first.iter.assert_is_valid();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::array_iterator>::simdjson_result(error_code error) noexcept\n : lasx::implementation_simdjson_result_base<lasx::ondemand::array_iterator>({}, error)\n{\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::array_iterator>::operator*() noexcept {\n if (error()) { return error(); }\n return *first;\n}\nsimdjson_inline bool simdjson_result<lasx::ondemand::array_iterator>::operator==(const simdjson_result<lasx::ondemand::array_iterator> &other) const noexcept {\n if (!first.iter.is_valid()) { return !error(); }\n return first == other.first;\n}\nsimdjson_inline bool simdjson_result<lasx::ondemand::array_iterator>::operator!=(const simdjson_result<lasx::ondemand::array_iterator> &other) const noexcept {\n if (!first.iter.is_valid()) { return error(); }\n return first != other.first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::array_iterator> &simdjson_result<lasx::ondemand::array_iterator>::operator++() noexcept {\n // Clear the error if there is one, so we don't yield it twice\n if (error()) { second = SUCCESS; return *this; }\n ++(first);\n return *this;\n}\nsimdjson_inline bool simdjson_result<lasx::ondemand::array_iterator>::at_end() const noexcept {\n return !first.iter.is_valid() || first.at_end();\n}\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_INL_H\n/* end file simdjson/generic/ondemand/array_iterator-inl.h for lasx */\n/* including simdjson/generic/ondemand/value-inl.h for lasx: #include \"simdjson/generic/ondemand/value-inl.h\" */\n/* begin file simdjson/generic/ondemand/value-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/array.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/array_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_type.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/object.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/raw_json_string.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\nsimdjson_inline value::value(const value_iterator &_iter) noexcept\n : iter{_iter}\n{\n}\nsimdjson_inline value value::start(const value_iterator &iter) noexcept {\n return iter;\n}\nsimdjson_inline value value::resume(const value_iterator &iter) noexcept {\n return iter;\n}\n\nsimdjson_inline simdjson_result<array> value::get_array() noexcept {\n return array::start(iter);\n}\nsimdjson_inline simdjson_result<object> value::get_object() noexcept {\n return object::start(iter);\n}\nsimdjson_inline simdjson_result<object> value::start_or_resume_object() noexcept {\n if (iter.at_start()) {\n return get_object();\n } else {\n return object::resume(iter);\n }\n}\n\nsimdjson_inline simdjson_result<raw_json_string> value::get_raw_json_string() noexcept {\n return iter.get_raw_json_string();\n}\nsimdjson_inline simdjson_result<std::string_view> value::get_string(bool allow_replacement) noexcept {\n return iter.get_string(allow_replacement);\n}\ntemplate <typename string_type>\nsimdjson_warn_unused simdjson_inline error_code value::get_string(string_type& receiver, bool allow_replacement) noexcept {\n return iter.get_string(receiver, allow_replacement);\n}\nsimdjson_inline simdjson_result<std::string_view> value::get_wobbly_string() noexcept {\n return iter.get_wobbly_string();\n}\nsimdjson_inline simdjson_result<double> value::get_double() noexcept {\n return iter.get_double();\n}\nsimdjson_inline simdjson_result<double> value::get_double_in_string() noexcept {\n return iter.get_double_in_string();\n}\nsimdjson_inline simdjson_result<uint64_t> value::get_uint64() noexcept {\n return iter.get_uint64();\n}\nsimdjson_inline simdjson_result<uint64_t> value::get_uint64_in_string() noexcept {\n return iter.get_uint64_in_string();\n}\nsimdjson_inline simdjson_result<int64_t> value::get_int64() noexcept {\n return iter.get_int64();\n}\nsimdjson_inline simdjson_result<int64_t> value::get_int64_in_string() noexcept {\n return iter.get_int64_in_string();\n}\nsimdjson_inline simdjson_result<bool> value::get_bool() noexcept {\n return iter.get_bool();\n}\nsimdjson_inline simdjson_result<bool> value::is_null() noexcept {\n return iter.is_null();\n}\n\ntemplate<> simdjson_inline simdjson_result<array> value::get() noexcept { return get_array(); }\ntemplate<> simdjson_inline simdjson_result<object> value::get() noexcept { return get_object(); }\ntemplate<> simdjson_inline simdjson_result<raw_json_string> value::get() noexcept { return get_raw_json_string(); }\ntemplate<> simdjson_inline simdjson_result<std::string_view> value::get() noexcept { return get_string(false); }\ntemplate<> simdjson_inline simdjson_result<number> value::get() noexcept { return get_number(); }\ntemplate<> simdjson_inline simdjson_result<double> value::get() noexcept { return get_double(); }\ntemplate<> simdjson_inline simdjson_result<uint64_t> value::get() noexcept { return get_uint64(); }\ntemplate<> simdjson_inline simdjson_result<int64_t> value::get() noexcept { return get_int64(); }\ntemplate<> simdjson_inline simdjson_result<bool> value::get() noexcept { return get_bool(); }\n\n\ntemplate<> simdjson_warn_unused simdjson_inline error_code value::get(array& out) noexcept { return get_array().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code value::get(object& out) noexcept { return get_object().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code value::get(raw_json_string& out) noexcept { return get_raw_json_string().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code value::get(std::string_view& out) noexcept { return get_string(false).get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code value::get(number& out) noexcept { return get_number().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code value::get(double& out) noexcept { return get_double().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code value::get(uint64_t& out) noexcept { return get_uint64().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code value::get(int64_t& out) noexcept { return get_int64().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code value::get(bool& out) noexcept { return get_bool().get(out); }\n\n#if SIMDJSON_EXCEPTIONS\ntemplate <class T>\nsimdjson_inline value::operator T() noexcept(false) {\n return get<T>();\n}\nsimdjson_inline value::operator array() noexcept(false) {\n return get_array();\n}\nsimdjson_inline value::operator object() noexcept(false) {\n return get_object();\n}\nsimdjson_inline value::operator uint64_t() noexcept(false) {\n return get_uint64();\n}\nsimdjson_inline value::operator int64_t() noexcept(false) {\n return get_int64();\n}\nsimdjson_inline value::operator double() noexcept(false) {\n return get_double();\n}\nsimdjson_inline value::operator std::string_view() noexcept(false) {\n return get_string(false);\n}\nsimdjson_inline value::operator raw_json_string() noexcept(false) {\n return get_raw_json_string();\n}\nsimdjson_inline value::operator bool() noexcept(false) {\n return get_bool();\n}\n#endif\n\nsimdjson_inline simdjson_result<array_iterator> value::begin() & noexcept {\n return get_array().begin();\n}\nsimdjson_inline simdjson_result<array_iterator> value::end() & noexcept {\n return {};\n}\nsimdjson_inline simdjson_result<size_t> value::count_elements() & noexcept {\n simdjson_result<size_t> answer;\n auto a = get_array();\n answer = a.count_elements();\n // count_elements leaves you pointing inside the array, at the first element.\n // We need to move back so that the user can create a new array (which requires that\n // we point at '[').\n iter.move_at_start();\n return answer;\n}\nsimdjson_inline simdjson_result<size_t> value::count_fields() & noexcept {\n simdjson_result<size_t> answer;\n auto a = get_object();\n answer = a.count_fields();\n iter.move_at_start();\n return answer;\n}\nsimdjson_inline simdjson_result<value> value::at(size_t index) noexcept {\n auto a = get_array();\n return a.at(index);\n}\n\nsimdjson_inline simdjson_result<value> value::find_field(std::string_view key) noexcept {\n return start_or_resume_object().find_field(key);\n}\nsimdjson_inline simdjson_result<value> value::find_field(const char *key) noexcept {\n return start_or_resume_object().find_field(key);\n}\n\nsimdjson_inline simdjson_result<value> value::find_field_unordered(std::string_view key) noexcept {\n return start_or_resume_object().find_field_unordered(key);\n}\nsimdjson_inline simdjson_result<value> value::find_field_unordered(const char *key) noexcept {\n return start_or_resume_object().find_field_unordered(key);\n}\n\nsimdjson_inline simdjson_result<value> value::operator[](std::string_view key) noexcept {\n return start_or_resume_object()[key];\n}\nsimdjson_inline simdjson_result<value> value::operator[](const char *key) noexcept {\n return start_or_resume_object()[key];\n}\n\nsimdjson_inline simdjson_result<json_type> value::type() noexcept {\n return iter.type();\n}\n\nsimdjson_inline simdjson_result<bool> value::is_scalar() noexcept {\n json_type this_type;\n auto error = type().get(this_type);\n if(error) { return error; }\n return ! ((this_type == json_type::array) || (this_type == json_type::object));\n}\n\nsimdjson_inline simdjson_result<bool> value::is_string() noexcept {\n json_type this_type;\n auto error = type().get(this_type);\n if(error) { return error; }\n return (this_type == json_type::string);\n}\n\n\nsimdjson_inline bool value::is_negative() noexcept {\n return iter.is_negative();\n}\n\nsimdjson_inline simdjson_result<bool> value::is_integer() noexcept {\n return iter.is_integer();\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<number_type> value::get_number_type() noexcept {\n return iter.get_number_type();\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<number> value::get_number() noexcept {\n return iter.get_number();\n}\n\nsimdjson_inline std::string_view value::raw_json_token() noexcept {\n return std::string_view(reinterpret_cast<const char*>(iter.peek_start()), iter.peek_start_length());\n}\n\nsimdjson_inline simdjson_result<std::string_view> value::raw_json() noexcept {\n json_type t;\n SIMDJSON_TRY(type().get(t));\n switch (t)\n {\n case json_type::array: {\n ondemand::array array;\n SIMDJSON_TRY(get_array().get(array));\n return array.raw_json();\n }\n case json_type::object: {\n ondemand::object object;\n SIMDJSON_TRY(get_object().get(object));\n return object.raw_json();\n }\n default:\n return raw_json_token();\n }\n}\n\nsimdjson_inline simdjson_result<const char *> value::current_location() noexcept {\n return iter.json_iter().current_location();\n}\n\nsimdjson_inline int32_t value::current_depth() const noexcept{\n return iter.json_iter().depth();\n}\n\ninline bool is_pointer_well_formed(std::string_view json_pointer) noexcept {\n if (simdjson_unlikely(json_pointer.empty())) { // can't be\n return false;\n }\n if (simdjson_unlikely(json_pointer[0] != '/')) {\n return false;\n }\n size_t escape = json_pointer.find('~');\n if (escape == std::string_view::npos) {\n return true;\n }\n if (escape == json_pointer.size() - 1) {\n return false;\n }\n if (json_pointer[escape + 1] != '0' && json_pointer[escape + 1] != '1') {\n return false;\n }\n return true;\n}\n\nsimdjson_inline simdjson_result<value> value::at_pointer(std::string_view json_pointer) noexcept {\n json_type t;\n SIMDJSON_TRY(type().get(t));\n switch (t)\n {\n case json_type::array:\n return (*this).get_array().at_pointer(json_pointer);\n case json_type::object:\n return (*this).get_object().at_pointer(json_pointer);\n default:\n // a non-empty string can be invalid, or accessing a primitive (issue 2154)\n if (is_pointer_well_formed(json_pointer)) {\n return NO_SUCH_FIELD;\n }\n return INVALID_JSON_POINTER;\n }\n}\n\nsimdjson_inline simdjson_result<value> value::at_path(std::string_view json_path) noexcept {\n json_type t;\n SIMDJSON_TRY(type().get(t));\n switch (t) {\n case json_type::array:\n return (*this).get_array().at_path(json_path);\n case json_type::object:\n return (*this).get_object().at_path(json_path);\n default:\n return INVALID_JSON_POINTER;\n }\n}\n\ninline simdjson_result<std::vector<value>> value::at_path_with_wildcard(std::string_view json_path) noexcept {\n json_type t;\n SIMDJSON_TRY(type().get(t));\n switch (t) {\n case json_type::array:\n return (*this).get_array().at_path_with_wildcard(json_path);\n case json_type::object:\n return (*this).get_object().at_path_with_wildcard(json_path);\n default:\n return INVALID_JSON_POINTER;\n }\n}\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::value>::simdjson_result(\n lasx::ondemand::value &&value\n) noexcept :\n implementation_simdjson_result_base<lasx::ondemand::value>(\n std::forward<lasx::ondemand::value>(value)\n )\n{\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value>::simdjson_result(\n error_code error\n) noexcept :\n implementation_simdjson_result_base<lasx::ondemand::value>(error)\n{\n}\nsimdjson_inline simdjson_result<size_t> simdjson_result<lasx::ondemand::value>::count_elements() & noexcept {\n if (error()) { return error(); }\n return first.count_elements();\n}\nsimdjson_inline simdjson_result<size_t> simdjson_result<lasx::ondemand::value>::count_fields() & noexcept {\n if (error()) { return error(); }\n return first.count_fields();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::at(size_t index) noexcept {\n if (error()) { return error(); }\n return first.at(index);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::array_iterator> simdjson_result<lasx::ondemand::value>::begin() & noexcept {\n if (error()) { return error(); }\n return first.begin();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::array_iterator> simdjson_result<lasx::ondemand::value>::end() & noexcept {\n if (error()) { return error(); }\n return {};\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::find_field(std::string_view key) noexcept {\n if (error()) { return error(); }\n return first.find_field(key);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::find_field(const char *key) noexcept {\n if (error()) { return error(); }\n return first.find_field(key);\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::find_field_unordered(std::string_view key) noexcept {\n if (error()) { return error(); }\n return first.find_field_unordered(key);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::find_field_unordered(const char *key) noexcept {\n if (error()) { return error(); }\n return first.find_field_unordered(key);\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::operator[](std::string_view key) noexcept {\n if (error()) { return error(); }\n return first[key];\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::operator[](const char *key) noexcept {\n if (error()) { return error(); }\n return first[key];\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::array> simdjson_result<lasx::ondemand::value>::get_array() noexcept {\n if (error()) { return error(); }\n return first.get_array();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::object> simdjson_result<lasx::ondemand::value>::get_object() noexcept {\n if (error()) { return error(); }\n return first.get_object();\n}\nsimdjson_inline simdjson_result<uint64_t> simdjson_result<lasx::ondemand::value>::get_uint64() noexcept {\n if (error()) { return error(); }\n return first.get_uint64();\n}\nsimdjson_inline simdjson_result<uint64_t> simdjson_result<lasx::ondemand::value>::get_uint64_in_string() noexcept {\n if (error()) { return error(); }\n return first.get_uint64_in_string();\n}\nsimdjson_inline simdjson_result<int64_t> simdjson_result<lasx::ondemand::value>::get_int64() noexcept {\n if (error()) { return error(); }\n return first.get_int64();\n}\nsimdjson_inline simdjson_result<int64_t> simdjson_result<lasx::ondemand::value>::get_int64_in_string() noexcept {\n if (error()) { return error(); }\n return first.get_int64_in_string();\n}\nsimdjson_inline simdjson_result<double> simdjson_result<lasx::ondemand::value>::get_double() noexcept {\n if (error()) { return error(); }\n return first.get_double();\n}\nsimdjson_inline simdjson_result<double> simdjson_result<lasx::ondemand::value>::get_double_in_string() noexcept {\n if (error()) { return error(); }\n return first.get_double_in_string();\n}\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::value>::get_string(bool allow_replacement) noexcept {\n if (error()) { return error(); }\n return first.get_string(allow_replacement);\n}\ntemplate <typename string_type>\nsimdjson_inline error_code simdjson_result<lasx::ondemand::value>::get_string(string_type& receiver, bool allow_replacement) noexcept {\n if (error()) { return error(); }\n return first.get_string(receiver, allow_replacement);\n}\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::value>::get_wobbly_string() noexcept {\n if (error()) { return error(); }\n return first.get_wobbly_string();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::raw_json_string> simdjson_result<lasx::ondemand::value>::get_raw_json_string() noexcept {\n if (error()) { return error(); }\n return first.get_raw_json_string();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::value>::get_bool() noexcept {\n if (error()) { return error(); }\n return first.get_bool();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::value>::is_null() noexcept {\n if (error()) { return error(); }\n return first.is_null();\n}\n\ntemplate<> simdjson_inline error_code simdjson_result<lasx::ondemand::value>::get<lasx::ondemand::value>(lasx::ondemand::value &out) noexcept {\n if (error()) { return error(); }\n out = first;\n return SUCCESS;\n}\n\ntemplate<typename T> simdjson_inline simdjson_result<T> simdjson_result<lasx::ondemand::value>::get() noexcept {\n if (error()) { return error(); }\n return first.get<T>();\n}\ntemplate<typename T> simdjson_inline error_code simdjson_result<lasx::ondemand::value>::get(T &out) noexcept {\n if (error()) { return error(); }\n return first.get<T>(out);\n}\n\ntemplate<> simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::get<lasx::ondemand::value>() noexcept {\n if (error()) { return error(); }\n return std::move(first);\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::json_type> simdjson_result<lasx::ondemand::value>::type() noexcept {\n if (error()) { return error(); }\n return first.type();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::value>::is_scalar() noexcept {\n if (error()) { return error(); }\n return first.is_scalar();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::value>::is_string() noexcept {\n if (error()) { return error(); }\n return first.is_string();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::value>::is_negative() noexcept {\n if (error()) { return error(); }\n return first.is_negative();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::value>::is_integer() noexcept {\n if (error()) { return error(); }\n return first.is_integer();\n}\nsimdjson_inline simdjson_result<lasx::number_type> simdjson_result<lasx::ondemand::value>::get_number_type() noexcept {\n if (error()) { return error(); }\n return first.get_number_type();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::number> simdjson_result<lasx::ondemand::value>::get_number() noexcept {\n if (error()) { return error(); }\n return first.get_number();\n}\n#if SIMDJSON_EXCEPTIONS\ntemplate <class T>\nsimdjson_inline simdjson_result<lasx::ondemand::value>::operator T() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first.get<T>();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value>::operator lasx::ondemand::array() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value>::operator lasx::ondemand::object() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value>::operator uint64_t() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value>::operator int64_t() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value>::operator double() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value>::operator std::string_view() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value>::operator lasx::ondemand::raw_json_string() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value>::operator bool() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\n#endif\n\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::value>::raw_json_token() noexcept {\n if (error()) { return error(); }\n return first.raw_json_token();\n}\n\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::value>::raw_json() noexcept {\n if (error()) { return error(); }\n return first.raw_json();\n}\n\nsimdjson_inline simdjson_result<const char *> simdjson_result<lasx::ondemand::value>::current_location() noexcept {\n if (error()) { return error(); }\n return first.current_location();\n}\n\nsimdjson_inline simdjson_result<int32_t> simdjson_result<lasx::ondemand::value>::current_depth() const noexcept {\n if (error()) { return error(); }\n return first.current_depth();\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::at_pointer(\n std::string_view json_pointer) noexcept {\n if (error()) {\n return error();\n }\n return first.at_pointer(json_pointer);\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::at_path(\n std::string_view json_path) noexcept {\n if (error()) {\n return error();\n }\n return first.at_path(json_path);\n}\n\ninline simdjson_result<std::vector<lasx::ondemand::value>> simdjson_result<lasx::ondemand::value>::at_path_with_wildcard(\n std::string_view json_path) noexcept {\n if (error()) {\n return error();\n }\n return first.at_path_with_wildcard(json_path);\n}\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H\n/* end file simdjson/generic/ondemand/value-inl.h for lasx */\n/* including simdjson/generic/ondemand/document-inl.h for lasx: #include \"simdjson/generic/ondemand/document-inl.h\" */\n/* begin file simdjson/generic/ondemand/document-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/array_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/document.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_type.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/raw_json_string.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/array-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_iterator-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/object-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value_iterator-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/deserialize.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\nsimdjson_inline document::document(ondemand::json_iterator &&_iter) noexcept\n : iter{std::forward<json_iterator>(_iter)}\n{\n logger::log_start_value(iter, \"document\");\n}\n\nsimdjson_inline document document::start(json_iterator &&iter) noexcept {\n return document(std::forward<json_iterator>(iter));\n}\n\ninline void document::rewind() noexcept {\n iter.rewind();\n}\n\ninline std::string document::to_debug_string() noexcept {\n return iter.to_string();\n}\n\ninline simdjson_result<const char *> document::current_location() const noexcept {\n return iter.current_location();\n}\n\ninline int32_t document::current_depth() const noexcept {\n return iter.depth();\n}\n\ninline bool document::at_end() const noexcept {\n return iter.at_end();\n}\n\n\ninline bool document::is_alive() noexcept {\n return iter.is_alive();\n}\nsimdjson_inline value_iterator document::resume_value_iterator() noexcept {\n return value_iterator(&iter, 1, iter.root_position());\n}\nsimdjson_inline value_iterator document::get_root_value_iterator() noexcept {\n return resume_value_iterator();\n}\nsimdjson_inline simdjson_result<object> document::start_or_resume_object() noexcept {\n if (iter.at_root()) {\n return get_object();\n } else {\n return object::resume(resume_value_iterator());\n }\n}\nsimdjson_inline simdjson_result<value> document::get_value() noexcept {\n // Make sure we start any arrays or objects before returning, so that start_root_<object/array>()\n // gets called.\n\n // It is the convention throughout the code that the macro `SIMDJSON_DEVELOPMENT_CHECKS` determines whether\n // we check for OUT_OF_ORDER_ITERATION. Proper on::demand code should never trigger this error.\n#if SIMDJSON_DEVELOPMENT_CHECKS\n if (!iter.at_root()) { return OUT_OF_ORDER_ITERATION; }\n#endif\n // assert_at_root() serves two purposes: in Debug mode, whether or not\n // SIMDJSON_DEVELOPMENT_CHECKS is set or not, it checks that we are at the root of\n // the document (this will typically be redundant). In release mode, it generates\n // SIMDJSON_ASSUME statements to allow the compiler to make assumptions.\n iter.assert_at_root();\n switch (*iter.peek()) {\n case '[': {\n // The following lines check that the document ends with ].\n auto value_iterator = get_root_value_iterator();\n auto error = value_iterator.check_root_array();\n if(error) { return error; }\n return value(get_root_value_iterator());\n }\n case '{': {\n // The following lines would check that the document ends with }.\n auto value_iterator = get_root_value_iterator();\n auto error = value_iterator.check_root_object();\n if(error) { return error; }\n return value(get_root_value_iterator());\n }\n default:\n // Unfortunately, scalar documents are a special case in simdjson and they cannot\n // be safely converted to value instances.\n return SCALAR_DOCUMENT_AS_VALUE;\n }\n}\nsimdjson_inline simdjson_result<array> document::get_array() & noexcept {\n auto value = get_root_value_iterator();\n return array::start_root(value);\n}\nsimdjson_inline simdjson_result<object> document::get_object() & noexcept {\n auto value = get_root_value_iterator();\n return object::start_root(value);\n}\n\n/**\n * We decided that calling 'get_double()' on the JSON document '1.233 blabla' should\n * give an error, so we check for trailing content. We want to disallow trailing\n * content.\n * Thus, in several implementations below, we pass a 'true' parameter value to\n * a get_root_value_iterator() method: this indicates that we disallow trailing content.\n */\n\nsimdjson_inline simdjson_result<uint64_t> document::get_uint64() noexcept {\n return get_root_value_iterator().get_root_uint64(true);\n}\nsimdjson_inline simdjson_result<uint64_t> document::get_uint64_in_string() noexcept {\n return get_root_value_iterator().get_root_uint64_in_string(true);\n}\nsimdjson_inline simdjson_result<int64_t> document::get_int64() noexcept {\n return get_root_value_iterator().get_root_int64(true);\n}\nsimdjson_inline simdjson_result<int64_t> document::get_int64_in_string() noexcept {\n return get_root_value_iterator().get_root_int64_in_string(true);\n}\nsimdjson_inline simdjson_result<double> document::get_double() noexcept {\n return get_root_value_iterator().get_root_double(true);\n}\nsimdjson_inline simdjson_result<double> document::get_double_in_string() noexcept {\n return get_root_value_iterator().get_root_double_in_string(true);\n}\nsimdjson_inline simdjson_result<std::string_view> document::get_string(bool allow_replacement) noexcept {\n return get_root_value_iterator().get_root_string(true, allow_replacement);\n}\ntemplate <typename string_type>\nsimdjson_warn_unused simdjson_inline error_code document::get_string(string_type& receiver, bool allow_replacement) noexcept {\n return get_root_value_iterator().get_root_string(receiver, true, allow_replacement);\n}\nsimdjson_inline simdjson_result<std::string_view> document::get_wobbly_string() noexcept {\n return get_root_value_iterator().get_root_wobbly_string(true);\n}\nsimdjson_inline simdjson_result<raw_json_string> document::get_raw_json_string() noexcept {\n return get_root_value_iterator().get_root_raw_json_string(true);\n}\nsimdjson_inline simdjson_result<bool> document::get_bool() noexcept {\n return get_root_value_iterator().get_root_bool(true);\n}\nsimdjson_inline simdjson_result<bool> document::is_null() noexcept {\n return get_root_value_iterator().is_root_null(true);\n}\n\ntemplate<> simdjson_inline simdjson_result<array> document::get() & noexcept { return get_array(); }\ntemplate<> simdjson_inline simdjson_result<object> document::get() & noexcept { return get_object(); }\ntemplate<> simdjson_inline simdjson_result<raw_json_string> document::get() & noexcept { return get_raw_json_string(); }\ntemplate<> simdjson_inline simdjson_result<std::string_view> document::get() & noexcept { return get_string(false); }\ntemplate<> simdjson_inline simdjson_result<double> document::get() & noexcept { return get_double(); }\ntemplate<> simdjson_inline simdjson_result<uint64_t> document::get() & noexcept { return get_uint64(); }\ntemplate<> simdjson_inline simdjson_result<int64_t> document::get() & noexcept { return get_int64(); }\ntemplate<> simdjson_inline simdjson_result<bool> document::get() & noexcept { return get_bool(); }\ntemplate<> simdjson_inline simdjson_result<value> document::get() & noexcept { return get_value(); }\n\ntemplate<> simdjson_warn_unused simdjson_inline error_code document::get(array& out) & noexcept { return get_array().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code document::get(object& out) & noexcept { return get_object().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code document::get(raw_json_string& out) & noexcept { return get_raw_json_string().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code document::get(std::string_view& out) & noexcept { return get_string(false).get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code document::get(double& out) & noexcept { return get_double().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code document::get(uint64_t& out) & noexcept { return get_uint64().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code document::get(int64_t& out) & noexcept { return get_int64().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code document::get(bool& out) & noexcept { return get_bool().get(out); }\ntemplate<> simdjson_warn_unused simdjson_inline error_code document::get(value& out) & noexcept { return get_value().get(out); }\n\ntemplate<> simdjson_deprecated simdjson_inline simdjson_result<raw_json_string> document::get() && noexcept { return get_raw_json_string(); }\ntemplate<> simdjson_deprecated simdjson_inline simdjson_result<std::string_view> document::get() && noexcept { return get_string(false); }\ntemplate<> simdjson_deprecated simdjson_inline simdjson_result<double> document::get() && noexcept { return std::forward<document>(*this).get_double(); }\ntemplate<> simdjson_deprecated simdjson_inline simdjson_result<uint64_t> document::get() && noexcept { return std::forward<document>(*this).get_uint64(); }\ntemplate<> simdjson_deprecated simdjson_inline simdjson_result<int64_t> document::get() && noexcept { return std::forward<document>(*this).get_int64(); }\ntemplate<> simdjson_deprecated simdjson_inline simdjson_result<bool> document::get() && noexcept { return std::forward<document>(*this).get_bool(); }\ntemplate<> simdjson_deprecated simdjson_inline simdjson_result<value> document::get() && noexcept { return get_value(); }\n\n#if SIMDJSON_EXCEPTIONS\ntemplate <class T>\nsimdjson_deprecated simdjson_inline document::operator T() && noexcept(false) { return get<T>(); }\ntemplate <class T>\nsimdjson_inline document::operator T() & noexcept(false) { return get<T>(); }\nsimdjson_inline document::operator array() & noexcept(false) { return get_array(); }\nsimdjson_inline document::operator object() & noexcept(false) { return get_object(); }\nsimdjson_inline document::operator uint64_t() noexcept(false) { return get_uint64(); }\nsimdjson_inline document::operator int64_t() noexcept(false) { return get_int64(); }\nsimdjson_inline document::operator double() noexcept(false) { return get_double(); }\nsimdjson_inline document::operator std::string_view() noexcept(false) simdjson_lifetime_bound { return get_string(false); }\nsimdjson_inline document::operator raw_json_string() noexcept(false) simdjson_lifetime_bound { return get_raw_json_string(); }\nsimdjson_inline document::operator bool() noexcept(false) { return get_bool(); }\nsimdjson_inline document::operator value() noexcept(false) { return get_value(); }\n\n#endif\nsimdjson_inline simdjson_result<size_t> document::count_elements() & noexcept {\n auto a = get_array();\n simdjson_result<size_t> answer = a.count_elements();\n /* If there was an array, we are now left pointing at its first element. */\n if(answer.error() == SUCCESS) { rewind(); }\n return answer;\n}\nsimdjson_inline simdjson_result<size_t> document::count_fields() & noexcept {\n auto a = get_object();\n simdjson_result<size_t> answer = a.count_fields();\n /* If there was an object, we are now left pointing at its first element. */\n if(answer.error() == SUCCESS) { rewind(); }\n return answer;\n}\nsimdjson_inline simdjson_result<value> document::at(size_t index) & noexcept {\n auto a = get_array();\n return a.at(index);\n}\nsimdjson_inline simdjson_result<array_iterator> document::begin() & noexcept {\n return get_array().begin();\n}\nsimdjson_inline simdjson_result<array_iterator> document::end() & noexcept {\n return {};\n}\n\nsimdjson_inline simdjson_result<value> document::find_field(std::string_view key) & noexcept {\n return start_or_resume_object().find_field(key);\n}\nsimdjson_inline simdjson_result<value> document::find_field(const char *key) & noexcept {\n return start_or_resume_object().find_field(key);\n}\nsimdjson_inline simdjson_result<value> document::find_field_unordered(std::string_view key) & noexcept {\n return start_or_resume_object().find_field_unordered(key);\n}\nsimdjson_inline simdjson_result<value> document::find_field_unordered(const char *key) & noexcept {\n return start_or_resume_object().find_field_unordered(key);\n}\nsimdjson_inline simdjson_result<value> document::operator[](std::string_view key) & noexcept {\n return start_or_resume_object()[key];\n}\nsimdjson_inline simdjson_result<value> document::operator[](const char *key) & noexcept {\n return start_or_resume_object()[key];\n}\n\nsimdjson_warn_unused simdjson_inline error_code document::consume() noexcept {\n bool scalar = false;\n auto error = is_scalar().get(scalar);\n if(error) { return error; }\n if(scalar) {\n iter.return_current_and_advance();\n return SUCCESS;\n }\n error = iter.skip_child(0);\n if(error) { iter.abandon(); }\n return error;\n}\n\nsimdjson_inline simdjson_result<std::string_view> document::raw_json() noexcept {\n auto _iter = get_root_value_iterator();\n const uint8_t * starting_point{_iter.peek_start()};\n auto error = consume();\n if(error) { return error; }\n // After 'consume()', we could be left pointing just beyond the document, but that\n // is ok because we are not going to dereference the final pointer position, we just\n // use it to compute the length in bytes.\n const uint8_t * final_point{iter.unsafe_pointer()};\n return std::string_view(reinterpret_cast<const char*>(starting_point), size_t(final_point - starting_point));\n}\n\nsimdjson_inline simdjson_result<json_type> document::type() noexcept {\n return get_root_value_iterator().type();\n}\n\nsimdjson_inline simdjson_result<bool> document::is_scalar() noexcept {\n // For more speed, we could do:\n // return iter.is_single_token();\n json_type this_type;\n auto error = type().get(this_type);\n if(error) { return error; }\n return ! ((this_type == json_type::array) || (this_type == json_type::object));\n}\n\nsimdjson_inline simdjson_result<bool> document::is_string() noexcept {\n json_type this_type;\n auto error = type().get(this_type);\n if(error) { return error; }\n return (this_type == json_type::string);\n}\n\nsimdjson_inline bool document::is_negative() noexcept {\n return get_root_value_iterator().is_root_negative();\n}\n\nsimdjson_inline simdjson_result<bool> document::is_integer() noexcept {\n return get_root_value_iterator().is_root_integer(true);\n}\n\nsimdjson_inline simdjson_result<number_type> document::get_number_type() noexcept {\n return get_root_value_iterator().get_root_number_type(true);\n}\n\nsimdjson_inline simdjson_result<number> document::get_number() noexcept {\n return get_root_value_iterator().get_root_number(true);\n}\n\n\nsimdjson_inline simdjson_result<std::string_view> document::raw_json_token() noexcept {\n auto _iter = get_root_value_iterator();\n return std::string_view(reinterpret_cast<const char*>(_iter.peek_start()), _iter.peek_root_length());\n}\n\nsimdjson_inline simdjson_result<value> document::at_pointer(std::string_view json_pointer) noexcept {\n rewind(); // Rewind the document each time at_pointer is called\n if (json_pointer.empty()) {\n return this->get_value();\n }\n json_type t;\n SIMDJSON_TRY(type().get(t));\n switch (t)\n {\n case json_type::array:\n return (*this).get_array().at_pointer(json_pointer);\n case json_type::object:\n return (*this).get_object().at_pointer(json_pointer);\n default:\n return INVALID_JSON_POINTER;\n }\n}\n\nsimdjson_inline simdjson_result<value> document::at_path(std::string_view json_path) noexcept {\n rewind(); // Rewind the document each time at_pointer is called\n if (json_path.empty()) {\n return this->get_value();\n }\n json_type t;\n SIMDJSON_TRY(type().get(t));\n switch (t) {\n case json_type::array:\n return (*this).get_array().at_path(json_path);\n case json_type::object:\n return (*this).get_object().at_path(json_path);\n default:\n return INVALID_JSON_POINTER;\n }\n}\n\nsimdjson_inline simdjson_result<std::vector<value>> document::at_path_with_wildcard(std::string_view json_path) noexcept {\n rewind(); // Rewind the document each time at_path_with_wildcard is called\n if (json_path.empty()) {\n return INVALID_JSON_POINTER;\n }\n json_type t;\n SIMDJSON_TRY(type().get(t));\n switch (t) {\n case json_type::array:\n return (*this).get_array().at_path_with_wildcard(json_path);\n case json_type::object:\n return (*this).get_object().at_path_with_wildcard(json_path);\n default:\n return INVALID_JSON_POINTER;\n }\n}\n\n#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION\n\ntemplate<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\nsimdjson_warn_unused simdjson_inline error_code document::extract_into(T& out) & noexcept {\n // Helper to check if a field name matches any of the requested fields\n auto should_extract = [](std::string_view field_name) constexpr -> bool {\n return ((FieldNames.view() == field_name) || ...);\n };\n\n // Iterate through all members of T using reflection\n template for (constexpr auto mem : std::define_static_array(\n std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {\n\n if constexpr (!std::meta::is_const(mem) && std::meta::is_public(mem)) {\n constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));\n\n // Only extract this field if it's in our list of requested fields\n if constexpr (should_extract(key)) {\n // Try to find and extract the field\n if constexpr (concepts::optional_type<decltype(out.[:mem:])>) {\n // For optional fields, it's ok if they're missing\n auto field_result = find_field_unordered(key);\n if (!field_result.error()) {\n auto error = field_result.get(out.[:mem:]);\n if (error && error != NO_SUCH_FIELD) {\n return error;\n }\n } else if (field_result.error() != NO_SUCH_FIELD) {\n return field_result.error();\n } else {\n out.[:mem:].reset();\n }\n } else {\n // For required fields (in the requested list), fail if missing\n SIMDJSON_TRY((*this)[key].get(out.[:mem:]));\n }\n }\n }\n };\n\n return SUCCESS;\n}\n\n#endif // SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::document>::simdjson_result(\n lasx::ondemand::document &&value\n) noexcept :\n implementation_simdjson_result_base<lasx::ondemand::document>(\n std::forward<lasx::ondemand::document>(value)\n )\n{\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document>::simdjson_result(\n error_code error\n) noexcept :\n implementation_simdjson_result_base<lasx::ondemand::document>(\n error\n )\n{\n}\nsimdjson_inline simdjson_result<size_t> simdjson_result<lasx::ondemand::document>::count_elements() & noexcept {\n if (error()) { return error(); }\n return first.count_elements();\n}\nsimdjson_inline simdjson_result<size_t> simdjson_result<lasx::ondemand::document>::count_fields() & noexcept {\n if (error()) { return error(); }\n return first.count_fields();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document>::at(size_t index) & noexcept {\n if (error()) { return error(); }\n return first.at(index);\n}\nsimdjson_inline error_code simdjson_result<lasx::ondemand::document>::rewind() noexcept {\n if (error()) { return error(); }\n first.rewind();\n return SUCCESS;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::array_iterator> simdjson_result<lasx::ondemand::document>::begin() & noexcept {\n if (error()) { return error(); }\n return first.begin();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::array_iterator> simdjson_result<lasx::ondemand::document>::end() & noexcept {\n return {};\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document>::find_field_unordered(std::string_view key) & noexcept {\n if (error()) { return error(); }\n return first.find_field_unordered(key);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document>::find_field_unordered(const char *key) & noexcept {\n if (error()) { return error(); }\n return first.find_field_unordered(key);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document>::operator[](std::string_view key) & noexcept {\n if (error()) { return error(); }\n return first[key];\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document>::operator[](const char *key) & noexcept {\n if (error()) { return error(); }\n return first[key];\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document>::find_field(std::string_view key) & noexcept {\n if (error()) { return error(); }\n return first.find_field(key);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document>::find_field(const char *key) & noexcept {\n if (error()) { return error(); }\n return first.find_field(key);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::array> simdjson_result<lasx::ondemand::document>::get_array() & noexcept {\n if (error()) { return error(); }\n return first.get_array();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::object> simdjson_result<lasx::ondemand::document>::get_object() & noexcept {\n if (error()) { return error(); }\n return first.get_object();\n}\nsimdjson_inline simdjson_result<uint64_t> simdjson_result<lasx::ondemand::document>::get_uint64() noexcept {\n if (error()) { return error(); }\n return first.get_uint64();\n}\nsimdjson_inline simdjson_result<uint64_t> simdjson_result<lasx::ondemand::document>::get_uint64_in_string() noexcept {\n if (error()) { return error(); }\n return first.get_uint64_in_string();\n}\nsimdjson_inline simdjson_result<int64_t> simdjson_result<lasx::ondemand::document>::get_int64() noexcept {\n if (error()) { return error(); }\n return first.get_int64();\n}\nsimdjson_inline simdjson_result<int64_t> simdjson_result<lasx::ondemand::document>::get_int64_in_string() noexcept {\n if (error()) { return error(); }\n return first.get_int64_in_string();\n}\nsimdjson_inline simdjson_result<double> simdjson_result<lasx::ondemand::document>::get_double() noexcept {\n if (error()) { return error(); }\n return first.get_double();\n}\nsimdjson_inline simdjson_result<double> simdjson_result<lasx::ondemand::document>::get_double_in_string() noexcept {\n if (error()) { return error(); }\n return first.get_double_in_string();\n}\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::document>::get_string(bool allow_replacement) noexcept {\n if (error()) { return error(); }\n return first.get_string(allow_replacement);\n}\ntemplate <typename string_type>\nsimdjson_warn_unused simdjson_inline error_code simdjson_result<lasx::ondemand::document>::get_string(string_type& receiver, bool allow_replacement) noexcept {\n if (error()) { return error(); }\n return first.get_string(receiver, allow_replacement);\n}\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::document>::get_wobbly_string() noexcept {\n if (error()) { return error(); }\n return first.get_wobbly_string();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::raw_json_string> simdjson_result<lasx::ondemand::document>::get_raw_json_string() noexcept {\n if (error()) { return error(); }\n return first.get_raw_json_string();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document>::get_bool() noexcept {\n if (error()) { return error(); }\n return first.get_bool();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document>::get_value() noexcept {\n if (error()) { return error(); }\n return first.get_value();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document>::is_null() noexcept {\n if (error()) { return error(); }\n return first.is_null();\n}\n\ntemplate<typename T>\nsimdjson_inline simdjson_result<T> simdjson_result<lasx::ondemand::document>::get() & noexcept {\n if (error()) { return error(); }\n return first.get<T>();\n}\ntemplate<typename T>\nsimdjson_deprecated simdjson_inline simdjson_result<T> simdjson_result<lasx::ondemand::document>::get() && noexcept {\n if (error()) { return error(); }\n return std::forward<lasx::ondemand::document>(first).get<T>();\n}\ntemplate<typename T>\nsimdjson_warn_unused simdjson_inline error_code simdjson_result<lasx::ondemand::document>::get(T &out) & noexcept {\n if (error()) { return error(); }\n return first.get<T>(out);\n}\ntemplate<typename T>\nsimdjson_warn_unused simdjson_inline error_code simdjson_result<lasx::ondemand::document>::get(T &out) && noexcept {\n if (error()) { return error(); }\n return std::forward<lasx::ondemand::document>(first).get<T>(out);\n}\n\ntemplate<> simdjson_inline simdjson_result<lasx::ondemand::document> simdjson_result<lasx::ondemand::document>::get<lasx::ondemand::document>() & noexcept = delete;\ntemplate<> simdjson_deprecated simdjson_inline simdjson_result<lasx::ondemand::document> simdjson_result<lasx::ondemand::document>::get<lasx::ondemand::document>() && noexcept {\n if (error()) { return error(); }\n return std::forward<lasx::ondemand::document>(first);\n}\ntemplate<> simdjson_warn_unused simdjson_inline error_code simdjson_result<lasx::ondemand::document>::get<lasx::ondemand::document>(lasx::ondemand::document &out) & noexcept = delete;\ntemplate<> simdjson_warn_unused simdjson_inline error_code simdjson_result<lasx::ondemand::document>::get<lasx::ondemand::document>(lasx::ondemand::document &out) && noexcept {\n if (error()) { return error(); }\n out = std::forward<lasx::ondemand::document>(first);\n return SUCCESS;\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::json_type> simdjson_result<lasx::ondemand::document>::type() noexcept {\n if (error()) { return error(); }\n return first.type();\n}\n\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document>::is_scalar() noexcept {\n if (error()) { return error(); }\n return first.is_scalar();\n}\n\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document>::is_string() noexcept {\n if (error()) { return error(); }\n return first.is_string();\n}\n\nsimdjson_inline bool simdjson_result<lasx::ondemand::document>::is_negative() noexcept {\n if (error()) { return error(); }\n return first.is_negative();\n}\n\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document>::is_integer() noexcept {\n if (error()) { return error(); }\n return first.is_integer();\n}\n\nsimdjson_inline simdjson_result<lasx::number_type> simdjson_result<lasx::ondemand::document>::get_number_type() noexcept {\n if (error()) { return error(); }\n return first.get_number_type();\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::number> simdjson_result<lasx::ondemand::document>::get_number() noexcept {\n if (error()) { return error(); }\n return first.get_number();\n}\n\n\n#if SIMDJSON_EXCEPTIONS\ntemplate <class T, typename std::enable_if<std::is_same<T, lasx::ondemand::document>::value == false>::type>\nsimdjson_inline simdjson_result<lasx::ondemand::document>::operator T() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document>::operator lasx::ondemand::array() & noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document>::operator lasx::ondemand::object() & noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document>::operator uint64_t() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document>::operator int64_t() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document>::operator double() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document>::operator std::string_view() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document>::operator lasx::ondemand::raw_json_string() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document>::operator bool() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document>::operator lasx::ondemand::value() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\n#endif\n\n\nsimdjson_inline simdjson_result<const char *> simdjson_result<lasx::ondemand::document>::current_location() noexcept {\n if (error()) { return error(); }\n return first.current_location();\n}\n\nsimdjson_inline bool simdjson_result<lasx::ondemand::document>::at_end() const noexcept {\n if (error()) { return error(); }\n return first.at_end();\n}\n\n\nsimdjson_inline int32_t simdjson_result<lasx::ondemand::document>::current_depth() const noexcept {\n if (error()) { return error(); }\n return first.current_depth();\n}\n\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::document>::raw_json_token() noexcept {\n if (error()) { return error(); }\n return first.raw_json_token();\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document>::at_pointer(std::string_view json_pointer) noexcept {\n if (error()) { return error(); }\n return first.at_pointer(json_pointer);\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document>::at_path(std::string_view json_path) noexcept {\n if (error()) { return error(); }\n return first.at_path(json_path);\n}\n\nsimdjson_inline simdjson_result<std::vector<lasx::ondemand::value>> simdjson_result<lasx::ondemand::document>::at_path_with_wildcard(std::string_view json_path) noexcept {\n if (error()) { return error(); }\n return first.at_path_with_wildcard(json_path);\n}\n\n#if SIMDJSON_STATIC_REFLECTION\ntemplate<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\nsimdjson_warn_unused simdjson_inline error_code simdjson_result<lasx::ondemand::document>::extract_into(T& out) & noexcept {\n if (error()) { return error(); }\n return first.extract_into<FieldNames...>(out);\n}\n#endif // SIMDJSON_STATIC_REFLECTION\n\n} // namespace simdjson\n\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\nsimdjson_inline document_reference::document_reference() noexcept : doc{nullptr} {}\nsimdjson_inline document_reference::document_reference(document &d) noexcept : doc(&d) {}\nsimdjson_inline void document_reference::rewind() noexcept { doc->rewind(); }\nsimdjson_inline simdjson_result<array> document_reference::get_array() & noexcept { return doc->get_array(); }\nsimdjson_inline simdjson_result<object> document_reference::get_object() & noexcept { return doc->get_object(); }\n/**\n * The document_reference instances are used primarily/solely for streams of JSON\n * documents.\n * We decided that calling 'get_double()' on the JSON document '1.233 blabla' should\n * give an error, so we check for trailing content.\n *\n * However, for streams of JSON documents, we want to be able to start from\n * \"321\" \"321\" \"321\"\n * and parse it successfully as a stream of JSON documents, calling get_uint64_in_string()\n * successfully each time.\n *\n * To achieve this result, we pass a 'false' to a get_root_value_iterator() method:\n * this indicates that we allow trailing content.\n */\nsimdjson_inline simdjson_result<uint64_t> document_reference::get_uint64() noexcept { return doc->get_root_value_iterator().get_root_uint64(false); }\nsimdjson_inline simdjson_result<uint64_t> document_reference::get_uint64_in_string() noexcept { return doc->get_root_value_iterator().get_root_uint64_in_string(false); }\nsimdjson_inline simdjson_result<int64_t> document_reference::get_int64() noexcept { return doc->get_root_value_iterator().get_root_int64(false); }\nsimdjson_inline simdjson_result<int64_t> document_reference::get_int64_in_string() noexcept { return doc->get_root_value_iterator().get_root_int64_in_string(false); }\nsimdjson_inline simdjson_result<double> document_reference::get_double() noexcept { return doc->get_root_value_iterator().get_root_double(false); }\nsimdjson_inline simdjson_result<double> document_reference::get_double_in_string() noexcept { return doc->get_root_value_iterator().get_root_double(false); }\nsimdjson_inline simdjson_result<std::string_view> document_reference::get_string(bool allow_replacement) noexcept { return doc->get_root_value_iterator().get_root_string(false, allow_replacement); }\ntemplate <typename string_type>\nsimdjson_warn_unused simdjson_inline error_code document_reference::get_string(string_type& receiver, bool allow_replacement) noexcept { return doc->get_root_value_iterator().get_root_string(receiver, false, allow_replacement); }\nsimdjson_inline simdjson_result<std::string_view> document_reference::get_wobbly_string() noexcept { return doc->get_root_value_iterator().get_root_wobbly_string(false); }\nsimdjson_inline simdjson_result<raw_json_string> document_reference::get_raw_json_string() noexcept { return doc->get_root_value_iterator().get_root_raw_json_string(false); }\nsimdjson_inline simdjson_result<bool> document_reference::get_bool() noexcept { return doc->get_root_value_iterator().get_root_bool(false); }\nsimdjson_inline simdjson_result<value> document_reference::get_value() noexcept { return doc->get_value(); }\nsimdjson_inline simdjson_result<bool> document_reference::is_null() noexcept { return doc->get_root_value_iterator().is_root_null(false); }\ntemplate<> simdjson_inline simdjson_result<array> document_reference::get() & noexcept { return get_array(); }\ntemplate<> simdjson_inline simdjson_result<object> document_reference::get() & noexcept { return get_object(); }\ntemplate<> simdjson_inline simdjson_result<raw_json_string> document_reference::get() & noexcept { return get_raw_json_string(); }\ntemplate<> simdjson_inline simdjson_result<std::string_view> document_reference::get() & noexcept { return get_string(false); }\ntemplate<> simdjson_inline simdjson_result<double> document_reference::get() & noexcept { return get_double(); }\ntemplate<> simdjson_inline simdjson_result<uint64_t> document_reference::get() & noexcept { return get_uint64(); }\ntemplate<> simdjson_inline simdjson_result<int64_t> document_reference::get() & noexcept { return get_int64(); }\ntemplate<> simdjson_inline simdjson_result<bool> document_reference::get() & noexcept { return get_bool(); }\ntemplate<> simdjson_inline simdjson_result<value> document_reference::get() & noexcept { return get_value(); }\n#if SIMDJSON_EXCEPTIONS\ntemplate <class T>\nsimdjson_inline document_reference::operator T() noexcept(false) { return get<T>(); }\nsimdjson_inline document_reference::operator array() & noexcept(false) { return array(*doc); }\nsimdjson_inline document_reference::operator object() & noexcept(false) { return object(*doc); }\nsimdjson_inline document_reference::operator uint64_t() noexcept(false) { return get_uint64(); }\nsimdjson_inline document_reference::operator int64_t() noexcept(false) { return get_int64(); }\nsimdjson_inline document_reference::operator double() noexcept(false) { return get_double(); }\nsimdjson_inline document_reference::operator std::string_view() noexcept(false) { return std::string_view(*doc); }\nsimdjson_inline document_reference::operator raw_json_string() noexcept(false) { return get_raw_json_string(); }\nsimdjson_inline document_reference::operator bool() noexcept(false) { return get_bool(); }\nsimdjson_inline document_reference::operator value() noexcept(false) { return value(*doc); }\n#endif\nsimdjson_inline simdjson_result<size_t> document_reference::count_elements() & noexcept { return doc->count_elements(); }\nsimdjson_inline simdjson_result<size_t> document_reference::count_fields() & noexcept { return doc->count_fields(); }\nsimdjson_inline simdjson_result<value> document_reference::at(size_t index) & noexcept { return doc->at(index); }\nsimdjson_inline simdjson_result<array_iterator> document_reference::begin() & noexcept { return doc->begin(); }\nsimdjson_inline simdjson_result<array_iterator> document_reference::end() & noexcept { return doc->end(); }\nsimdjson_inline simdjson_result<value> document_reference::find_field(std::string_view key) & noexcept { return doc->find_field(key); }\nsimdjson_inline simdjson_result<value> document_reference::find_field(const char *key) & noexcept { return doc->find_field(key); }\nsimdjson_inline simdjson_result<value> document_reference::operator[](std::string_view key) & noexcept { return (*doc)[key]; }\nsimdjson_inline simdjson_result<value> document_reference::operator[](const char *key) & noexcept { return (*doc)[key]; }\nsimdjson_inline simdjson_result<value> document_reference::find_field_unordered(std::string_view key) & noexcept { return doc->find_field_unordered(key); }\nsimdjson_inline simdjson_result<value> document_reference::find_field_unordered(const char *key) & noexcept { return doc->find_field_unordered(key); }\nsimdjson_inline simdjson_result<json_type> document_reference::type() noexcept { return doc->type(); }\nsimdjson_inline simdjson_result<bool> document_reference::is_scalar() noexcept { return doc->is_scalar(); }\nsimdjson_inline simdjson_result<bool> document_reference::is_string() noexcept { return doc->is_string(); }\nsimdjson_inline simdjson_result<const char *> document_reference::current_location() noexcept { return doc->current_location(); }\nsimdjson_inline int32_t document_reference::current_depth() const noexcept { return doc->current_depth(); }\nsimdjson_inline bool document_reference::is_negative() noexcept { return doc->is_negative(); }\nsimdjson_inline simdjson_result<bool> document_reference::is_integer() noexcept { return doc->get_root_value_iterator().is_root_integer(false); }\nsimdjson_inline simdjson_result<number_type> document_reference::get_number_type() noexcept { return doc->get_root_value_iterator().get_root_number_type(false); }\nsimdjson_inline simdjson_result<number> document_reference::get_number() noexcept { return doc->get_root_value_iterator().get_root_number(false); }\nsimdjson_inline simdjson_result<std::string_view> document_reference::raw_json_token() noexcept { return doc->raw_json_token(); }\nsimdjson_inline simdjson_result<value> document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); }\nsimdjson_inline simdjson_result<value> document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); }\nsimdjson_inline simdjson_result<std::vector<value>> document_reference::at_path_with_wildcard(std::string_view json_path) noexcept { return doc->at_path_with_wildcard(json_path); }\nsimdjson_inline simdjson_result<std::string_view> document_reference::raw_json() noexcept { return doc->raw_json();}\nsimdjson_inline document_reference::operator document&() const noexcept { return *doc; }\n#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION\ntemplate<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\nsimdjson_warn_unused simdjson_inline error_code document_reference::extract_into(T& out) & noexcept {\n return doc->extract_into<FieldNames...>(out);\n}\n#endif // SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\n\n\nnamespace simdjson {\nsimdjson_inline simdjson_result<lasx::ondemand::document_reference>::simdjson_result(lasx::ondemand::document_reference value, error_code error)\n noexcept : implementation_simdjson_result_base<lasx::ondemand::document_reference>(std::forward<lasx::ondemand::document_reference>(value), error) {}\n\n\nsimdjson_inline simdjson_result<size_t> simdjson_result<lasx::ondemand::document_reference>::count_elements() & noexcept {\n if (error()) { return error(); }\n return first.count_elements();\n}\nsimdjson_inline simdjson_result<size_t> simdjson_result<lasx::ondemand::document_reference>::count_fields() & noexcept {\n if (error()) { return error(); }\n return first.count_fields();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::at(size_t index) & noexcept {\n if (error()) { return error(); }\n return first.at(index);\n}\nsimdjson_inline error_code simdjson_result<lasx::ondemand::document_reference>::rewind() noexcept {\n if (error()) { return error(); }\n first.rewind();\n return SUCCESS;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::array_iterator> simdjson_result<lasx::ondemand::document_reference>::begin() & noexcept {\n if (error()) { return error(); }\n return first.begin();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::array_iterator> simdjson_result<lasx::ondemand::document_reference>::end() & noexcept {\n return {};\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::find_field_unordered(std::string_view key) & noexcept {\n if (error()) { return error(); }\n return first.find_field_unordered(key);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::find_field_unordered(const char *key) & noexcept {\n if (error()) { return error(); }\n return first.find_field_unordered(key);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::operator[](std::string_view key) & noexcept {\n if (error()) { return error(); }\n return first[key];\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::operator[](const char *key) & noexcept {\n if (error()) { return error(); }\n return first[key];\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::find_field(std::string_view key) & noexcept {\n if (error()) { return error(); }\n return first.find_field(key);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::find_field(const char *key) & noexcept {\n if (error()) { return error(); }\n return first.find_field(key);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::array> simdjson_result<lasx::ondemand::document_reference>::get_array() & noexcept {\n if (error()) { return error(); }\n return first.get_array();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::object> simdjson_result<lasx::ondemand::document_reference>::get_object() & noexcept {\n if (error()) { return error(); }\n return first.get_object();\n}\nsimdjson_inline simdjson_result<uint64_t> simdjson_result<lasx::ondemand::document_reference>::get_uint64() noexcept {\n if (error()) { return error(); }\n return first.get_uint64();\n}\nsimdjson_inline simdjson_result<uint64_t> simdjson_result<lasx::ondemand::document_reference>::get_uint64_in_string() noexcept {\n if (error()) { return error(); }\n return first.get_uint64_in_string();\n}\nsimdjson_inline simdjson_result<int64_t> simdjson_result<lasx::ondemand::document_reference>::get_int64() noexcept {\n if (error()) { return error(); }\n return first.get_int64();\n}\nsimdjson_inline simdjson_result<int64_t> simdjson_result<lasx::ondemand::document_reference>::get_int64_in_string() noexcept {\n if (error()) { return error(); }\n return first.get_int64_in_string();\n}\nsimdjson_inline simdjson_result<double> simdjson_result<lasx::ondemand::document_reference>::get_double() noexcept {\n if (error()) { return error(); }\n return first.get_double();\n}\nsimdjson_inline simdjson_result<double> simdjson_result<lasx::ondemand::document_reference>::get_double_in_string() noexcept {\n if (error()) { return error(); }\n return first.get_double_in_string();\n}\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::document_reference>::get_string(bool allow_replacement) noexcept {\n if (error()) { return error(); }\n return first.get_string(allow_replacement);\n}\ntemplate <typename string_type>\nsimdjson_warn_unused simdjson_inline error_code simdjson_result<lasx::ondemand::document_reference>::get_string(string_type& receiver, bool allow_replacement) noexcept {\n if (error()) { return error(); }\n return first.get_string(receiver, allow_replacement);\n}\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::document_reference>::get_wobbly_string() noexcept {\n if (error()) { return error(); }\n return first.get_wobbly_string();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::raw_json_string> simdjson_result<lasx::ondemand::document_reference>::get_raw_json_string() noexcept {\n if (error()) { return error(); }\n return first.get_raw_json_string();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document_reference>::get_bool() noexcept {\n if (error()) { return error(); }\n return first.get_bool();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::get_value() noexcept {\n if (error()) { return error(); }\n return first.get_value();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document_reference>::is_null() noexcept {\n if (error()) { return error(); }\n return first.is_null();\n}\ntemplate<typename T>\nsimdjson_inline simdjson_result<T> simdjson_result<lasx::ondemand::document_reference>::get() & noexcept {\n if (error()) { return error(); }\n return first.get<T>();\n}\ntemplate<typename T>\nsimdjson_inline simdjson_result<T> simdjson_result<lasx::ondemand::document_reference>::get() && noexcept {\n if (error()) { return error(); }\n return std::forward<lasx::ondemand::document_reference>(first).get<T>();\n}\ntemplate <class T>\nsimdjson_warn_unused simdjson_inline error_code simdjson_result<lasx::ondemand::document_reference>::get(T &out) & noexcept {\n if (error()) { return error(); }\n return first.get<T>(out);\n}\ntemplate <class T>\nsimdjson_warn_unused simdjson_inline error_code simdjson_result<lasx::ondemand::document_reference>::get(T &out) && noexcept {\n if (error()) { return error(); }\n return std::forward<lasx::ondemand::document_reference>(first).get<T>(out);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::json_type> simdjson_result<lasx::ondemand::document_reference>::type() noexcept {\n if (error()) { return error(); }\n return first.type();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document_reference>::is_scalar() noexcept {\n if (error()) { return error(); }\n return first.is_scalar();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document_reference>::is_string() noexcept {\n if (error()) { return error(); }\n return first.is_string();\n}\ntemplate <>\nsimdjson_warn_unused simdjson_inline error_code simdjson_result<lasx::ondemand::document_reference>::get(lasx::ondemand::document_reference &out) & noexcept {\n if (error()) { return error(); }\n out = first;\n return SUCCESS;\n}\ntemplate <>\nsimdjson_warn_unused simdjson_inline error_code simdjson_result<lasx::ondemand::document_reference>::get(lasx::ondemand::document_reference &out) && noexcept {\n if (error()) { return error(); }\n out = first;\n return SUCCESS;\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document_reference>::is_negative() noexcept {\n if (error()) { return error(); }\n return first.is_negative();\n}\nsimdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document_reference>::is_integer() noexcept {\n if (error()) { return error(); }\n return first.is_integer();\n}\nsimdjson_inline simdjson_result<lasx::number_type> simdjson_result<lasx::ondemand::document_reference>::get_number_type() noexcept {\n if (error()) { return error(); }\n return first.get_number_type();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::number> simdjson_result<lasx::ondemand::document_reference>::get_number() noexcept {\n if (error()) { return error(); }\n return first.get_number();\n}\n#if SIMDJSON_EXCEPTIONS\ntemplate <class T>\nsimdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator T() noexcept(false) {\n static_assert(std::is_same<T, lasx::ondemand::document_reference>::value == false, \"You should not call get<T> when T is a document\");\n static_assert(std::is_same<T, lasx::ondemand::document>::value == false, \"You should not call get<T> when T is a document\");\n if (error()) { throw simdjson_error(error()); }\n return first.get<T>();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator lasx::ondemand::array() & noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator lasx::ondemand::object() & noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator uint64_t() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator int64_t() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator double() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator std::string_view() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator lasx::ondemand::raw_json_string() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator bool() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator lasx::ondemand::value() noexcept(false) {\n if (error()) { throw simdjson_error(error()); }\n return first;\n}\n#endif\n\nsimdjson_inline simdjson_result<const char *> simdjson_result<lasx::ondemand::document_reference>::current_location() noexcept {\n if (error()) { return error(); }\n return first.current_location();\n}\n\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::document_reference>::raw_json_token() noexcept {\n if (error()) { return error(); }\n return first.raw_json_token();\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::at_pointer(std::string_view json_pointer) noexcept {\n if (error()) { return error(); }\n return first.at_pointer(json_pointer);\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::at_path(std::string_view json_path) noexcept {\n if (error()) {\n return error();\n }\n return first.at_path(json_path);\n}\nsimdjson_inline simdjson_result<std::vector<lasx::ondemand::value>> simdjson_result<lasx::ondemand::document_reference>::at_path_with_wildcard(std::string_view json_path) noexcept {\n if (error()) {\n return error();\n }\n return first.at_path_with_wildcard(json_path);\n}\n#if SIMDJSON_STATIC_REFLECTION\ntemplate<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\nsimdjson_warn_unused simdjson_inline error_code simdjson_result<lasx::ondemand::document_reference>::extract_into(T& out) & noexcept {\n if (error()) { return error(); }\n return first.extract_into<FieldNames...>(out);\n}\n#endif // SIMDJSON_STATIC_REFLECTION\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_INL_H\n/* end file simdjson/generic/ondemand/document-inl.h for lasx */\n/* including simdjson/generic/ondemand/document_stream-inl.h for lasx: #include \"simdjson/generic/ondemand/document_stream-inl.h\" */\n/* begin file simdjson/generic/ondemand/document_stream-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/document_stream.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/document-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base-inl.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\n#include <algorithm>\n#include <stdexcept>\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\n#ifdef SIMDJSON_THREADS_ENABLED\n\ninline void stage1_worker::finish() {\n // After calling \"run\" someone would call finish() to wait\n // for the end of the processing.\n // This function will wait until either the thread has done\n // the processing or, else, the destructor has been called.\n std::unique_lock<std::mutex> lock(locking_mutex);\n cond_var.wait(lock, [this]{return has_work == false;});\n}\n\ninline stage1_worker::~stage1_worker() {\n // The thread may never outlive the stage1_worker instance\n // and will always be stopped/joined before the stage1_worker\n // instance is gone.\n stop_thread();\n}\n\ninline void stage1_worker::start_thread() {\n std::unique_lock<std::mutex> lock(locking_mutex);\n if(thread.joinable()) {\n return; // This should never happen but we never want to create more than one thread.\n }\n thread = std::thread([this]{\n while(true) {\n std::unique_lock<std::mutex> thread_lock(locking_mutex);\n // We wait for either \"run\" or \"stop_thread\" to be called.\n cond_var.wait(thread_lock, [this]{return has_work || !can_work;});\n // If, for some reason, the stop_thread() method was called (i.e., the\n // destructor of stage1_worker is called, then we want to immediately destroy\n // the thread (and not do any more processing).\n if(!can_work) {\n break;\n }\n this->owner->stage1_thread_error = this->owner->run_stage1(*this->stage1_thread_parser,\n this->_next_batch_start);\n this->has_work = false;\n // The condition variable call should be moved after thread_lock.unlock() for performance\n // reasons but thread sanitizers may report it as a data race if we do.\n // See https://stackoverflow.com/questions/35775501/c-should-condition-variable-be-notified-under-lock\n cond_var.notify_one(); // will notify \"finish\"\n thread_lock.unlock();\n }\n }\n );\n}\n\n\ninline void stage1_worker::stop_thread() {\n std::unique_lock<std::mutex> lock(locking_mutex);\n // We have to make sure that all locks can be released.\n can_work = false;\n has_work = false;\n cond_var.notify_all();\n lock.unlock();\n if(thread.joinable()) {\n thread.join();\n }\n}\n\ninline void stage1_worker::run(document_stream * ds, parser * stage1, size_t next_batch_start) {\n std::unique_lock<std::mutex> lock(locking_mutex);\n owner = ds;\n _next_batch_start = next_batch_start;\n stage1_thread_parser = stage1;\n has_work = true;\n // The condition variable call should be moved after thread_lock.unlock() for performance\n // reasons but thread sanitizers may report it as a data race if we do.\n // See https://stackoverflow.com/questions/35775501/c-should-condition-variable-be-notified-under-lock\n cond_var.notify_one(); // will notify the thread lock that we have work\n lock.unlock();\n}\n\n#endif // SIMDJSON_THREADS_ENABLED\n\nsimdjson_inline document_stream::document_stream(\n ondemand::parser &_parser,\n const uint8_t *_buf,\n size_t _len,\n size_t _batch_size,\n bool _allow_comma_separated\n) noexcept\n : parser{&_parser},\n buf{_buf},\n len{_len},\n batch_size{_batch_size <= MINIMAL_BATCH_SIZE ? MINIMAL_BATCH_SIZE : _batch_size},\n allow_comma_separated{_allow_comma_separated},\n error{SUCCESS}\n #ifdef SIMDJSON_THREADS_ENABLED\n , use_thread(_parser.threaded) // we need to make a copy because _parser.threaded can change\n #endif\n{\n#ifdef SIMDJSON_THREADS_ENABLED\n if(worker.get() == nullptr) {\n error = MEMALLOC;\n }\n#endif\n}\n\nsimdjson_inline document_stream::document_stream() noexcept\n : parser{nullptr},\n buf{nullptr},\n len{0},\n batch_size{0},\n allow_comma_separated{false},\n error{UNINITIALIZED}\n #ifdef SIMDJSON_THREADS_ENABLED\n , use_thread(false)\n #endif\n{\n}\n\nsimdjson_inline document_stream::~document_stream() noexcept\n{\n #ifdef SIMDJSON_THREADS_ENABLED\n worker.reset();\n #endif\n}\n\ninline size_t document_stream::size_in_bytes() const noexcept {\n return len;\n}\n\ninline size_t document_stream::truncated_bytes() const noexcept {\n if(error == CAPACITY) { return len - batch_start; }\n return parser->implementation->structural_indexes[parser->implementation->n_structural_indexes] - parser->implementation->structural_indexes[parser->implementation->n_structural_indexes + 1];\n}\n\nsimdjson_inline document_stream::iterator::iterator() noexcept\n : stream{nullptr}, finished{true} {\n}\n\nsimdjson_inline document_stream::iterator::iterator(document_stream* _stream, bool is_end) noexcept\n : stream{_stream}, finished{is_end} {\n}\n\nsimdjson_inline simdjson_result<ondemand::document_reference> document_stream::iterator::operator*() noexcept {\n return simdjson_result<ondemand::document_reference>(stream->doc, stream->error);\n}\n\nsimdjson_inline document_stream::iterator& document_stream::iterator::operator++() noexcept {\n // If there is an error, then we want the iterator\n // to be finished, no matter what. (E.g., we do not\n // keep generating documents with errors, or go beyond\n // a document with errors.)\n //\n // Users do not have to call \"operator*()\" when they use operator++,\n // so we need to end the stream in the operator++ function.\n //\n // Note that setting finished = true is essential otherwise\n // we would enter an infinite loop.\n if (stream->error) { finished = true; }\n // Note that stream->error() is guarded against error conditions\n // (it will immediately return if stream->error casts to false).\n // In effect, this next function does nothing when (stream->error)\n // is true (hence the risk of an infinite loop).\n stream->next();\n // If that was the last document, we're finished.\n // It is the only type of error we do not want to appear\n // in operator*.\n if (stream->error == EMPTY) { finished = true; }\n // If we had any other kind of error (not EMPTY) then we want\n // to pass it along to the operator* and we cannot mark the result\n // as \"finished\" just yet.\n return *this;\n}\n\nsimdjson_inline bool document_stream::iterator::at_end() const noexcept {\n return finished;\n}\n\n\nsimdjson_inline bool document_stream::iterator::operator!=(const document_stream::iterator &other) const noexcept {\n return finished != other.finished;\n}\n\nsimdjson_inline bool document_stream::iterator::operator==(const document_stream::iterator &other) const noexcept {\n return finished == other.finished;\n}\n\nsimdjson_inline document_stream::iterator document_stream::begin() noexcept {\n start();\n // If there are no documents, we're finished.\n return iterator(this, error == EMPTY);\n}\n\nsimdjson_inline document_stream::iterator document_stream::end() noexcept {\n return iterator(this, true);\n}\n\ninline void document_stream::start() noexcept {\n if (error) { return; }\n error = parser->allocate(batch_size);\n if (error) { return; }\n // Always run the first stage 1 parse immediately\n batch_start = 0;\n error = run_stage1(*parser, batch_start);\n while(error == EMPTY) {\n // In exceptional cases, we may start with an empty block\n batch_start = next_batch_start();\n if (batch_start >= len) { return; }\n error = run_stage1(*parser, batch_start);\n }\n if (error) { return; }\n doc_index = batch_start;\n doc = document(json_iterator(&buf[batch_start], parser));\n doc.iter._streaming = true;\n\n #ifdef SIMDJSON_THREADS_ENABLED\n if (use_thread && next_batch_start() < len) {\n // Kick off the first thread on next batch if needed\n error = stage1_thread_parser.allocate(batch_size);\n if (error) { return; }\n worker->start_thread();\n start_stage1_thread();\n if (error) { return; }\n }\n #endif // SIMDJSON_THREADS_ENABLED\n}\n\ninline void document_stream::next() noexcept {\n // We always enter at once once in an error condition.\n if (error) { return; }\n next_document();\n if (error) { return; }\n auto cur_struct_index = doc.iter._root - parser->implementation->structural_indexes.get();\n doc_index = batch_start + parser->implementation->structural_indexes[cur_struct_index];\n\n // Check if at end of structural indexes (i.e. at end of batch)\n if(cur_struct_index >= static_cast<int64_t>(parser->implementation->n_structural_indexes)) {\n error = EMPTY;\n // Load another batch (if available)\n while (error == EMPTY) {\n batch_start = next_batch_start();\n if (batch_start >= len) { break; }\n #ifdef SIMDJSON_THREADS_ENABLED\n if(use_thread) {\n load_from_stage1_thread();\n } else {\n error = run_stage1(*parser, batch_start);\n }\n #else\n error = run_stage1(*parser, batch_start);\n #endif\n /**\n * Whenever we move to another window, we need to update all pointers to make\n * it appear as if the input buffer started at the beginning of the window.\n *\n * Take this input:\n *\n * {\"z\":5} {\"1\":1,\"2\":2,\"4\":4} [7, 10, 9] [15, 11, 12, 13] [154, 110, 112, 1311]\n *\n * Say you process the following window...\n *\n * '{\"z\":5} {\"1\":1,\"2\":2,\"4\":4} [7, 10, 9]'\n *\n * When you do so, the json_iterator has a pointer at the beginning of the memory region\n * (pointing at the beginning of '{\"z\"...'.\n *\n * When you move to the window that starts at...\n *\n * '[7, 10, 9] [15, 11, 12, 13] ...\n *\n * then it is not sufficient to just run stage 1. You also need to re-anchor the\n * json_iterator so that it believes we are starting at '[7, 10, 9]...'.\n *\n * Under the DOM front-end, this gets done automatically because the parser owns\n * the pointer the data, and when you call stage1 and then stage2 on the same\n * parser, then stage2 will run on the pointer acquired by stage1.\n *\n * That is, stage1 calls \"this->buf = _buf\" so the parser remembers the buffer that\n * we used. But json_iterator has no callback when stage1 is called on the parser.\n * In fact, I think that the parser is unaware of json_iterator.\n *\n *\n * So we need to re-anchor the json_iterator after each call to stage 1 so that\n * all of the pointers are in sync.\n */\n doc.iter = json_iterator(&buf[batch_start], parser);\n doc.iter._streaming = true;\n /**\n * End of resync.\n */\n\n if (error) { continue; } // If the error was EMPTY, we may want to load another batch.\n doc_index = batch_start;\n }\n }\n}\n\ninline void document_stream::next_document() noexcept {\n // Go to next place where depth=0 (document depth)\n error = doc.iter.skip_child(0);\n if (error) { return; }\n // Always set depth=1 at the start of document\n doc.iter._depth = 1;\n // consume comma if comma separated is allowed\n if (allow_comma_separated) {\n error_code ignored = doc.iter.consume_character(',');\n static_cast<void>(ignored); // ignored on purpose\n }\n // Resets the string buffer at the beginning, thus invalidating the strings.\n doc.iter._string_buf_loc = parser->string_buf.get();\n doc.iter._root = doc.iter.position();\n}\n\ninline size_t document_stream::next_batch_start() const noexcept {\n return batch_start + parser->implementation->structural_indexes[parser->implementation->n_structural_indexes];\n}\n\ninline error_code document_stream::run_stage1(ondemand::parser &p, size_t _batch_start) noexcept {\n // This code only updates the structural index in the parser, it does not update any json_iterator\n // instance.\n size_t remaining = len - _batch_start;\n if (remaining <= batch_size) {\n return p.implementation->stage1(&buf[_batch_start], remaining, stage1_mode::streaming_final);\n } else {\n return p.implementation->stage1(&buf[_batch_start], batch_size, stage1_mode::streaming_partial);\n }\n}\n\nsimdjson_inline size_t document_stream::iterator::current_index() const noexcept {\n return stream->doc_index;\n}\n\nsimdjson_inline std::string_view document_stream::iterator::source() const noexcept {\n auto depth = stream->doc.iter.depth();\n auto cur_struct_index = stream->doc.iter._root - stream->parser->implementation->structural_indexes.get();\n\n // If at root, process the first token to determine if scalar value\n if (stream->doc.iter.at_root()) {\n switch (stream->buf[stream->batch_start + stream->parser->implementation->structural_indexes[cur_struct_index]]) {\n case '{': case '[': // Depth=1 already at start of document\n break;\n case '}': case ']':\n depth--;\n break;\n default: // Scalar value document\n // TODO: We could remove trailing whitespaces\n // This returns a string spanning from start of value to the beginning of the next document (excluded)\n {\n auto next_index = stream->parser->implementation->structural_indexes[++cur_struct_index];\n // normally the length would be next_index - current_index() - 1, except for the last document\n size_t svlen = next_index - current_index();\n const char *start = reinterpret_cast<const char*>(stream->buf) + current_index();\n while(svlen > 1 && (std::isspace(start[svlen-1]) || start[svlen-1] == '\\0')) {\n svlen--;\n }\n return std::string_view(start, svlen);\n }\n }\n cur_struct_index++;\n }\n\n while (cur_struct_index <= static_cast<int64_t>(stream->parser->implementation->n_structural_indexes)) {\n switch (stream->buf[stream->batch_start + stream->parser->implementation->structural_indexes[cur_struct_index]]) {\n case '{': case '[':\n depth++;\n break;\n case '}': case ']':\n depth--;\n break;\n }\n if (depth == 0) { break; }\n cur_struct_index++;\n }\n\n return std::string_view(reinterpret_cast<const char*>(stream->buf) + current_index(), stream->parser->implementation->structural_indexes[cur_struct_index] - current_index() + stream->batch_start + 1);;\n}\n\ninline error_code document_stream::iterator::error() const noexcept {\n return stream->error;\n}\n\n#ifdef SIMDJSON_THREADS_ENABLED\n\ninline void document_stream::load_from_stage1_thread() noexcept {\n worker->finish();\n // Swap to the parser that was loaded up in the thread. Make sure the parser has\n // enough memory to swap to, as well.\n std::swap(stage1_thread_parser,*parser);\n error = stage1_thread_error;\n if (error) { return; }\n\n // If there's anything left, start the stage 1 thread!\n if (next_batch_start() < len) {\n start_stage1_thread();\n }\n}\n\ninline void document_stream::start_stage1_thread() noexcept {\n // we call the thread on a lambda that will update\n // this->stage1_thread_error\n // there is only one thread that may write to this value\n // TODO this is NOT exception-safe.\n this->stage1_thread_error = UNINITIALIZED; // In case something goes wrong, make sure it's an error\n size_t _next_batch_start = this->next_batch_start();\n\n worker->run(this, & this->stage1_thread_parser, _next_batch_start);\n}\n\n#endif // SIMDJSON_THREADS_ENABLED\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::document_stream>::simdjson_result(\n error_code error\n) noexcept :\n implementation_simdjson_result_base<lasx::ondemand::document_stream>(error)\n{\n}\nsimdjson_inline simdjson_result<lasx::ondemand::document_stream>::simdjson_result(\n lasx::ondemand::document_stream &&value\n) noexcept :\n implementation_simdjson_result_base<lasx::ondemand::document_stream>(\n std::forward<lasx::ondemand::document_stream>(value)\n )\n{\n}\n\n}\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_INL_H\n/* end file simdjson/generic/ondemand/document_stream-inl.h for lasx */\n/* including simdjson/generic/ondemand/field-inl.h for lasx: #include \"simdjson/generic/ondemand/field-inl.h\" */\n/* begin file simdjson/generic/ondemand/field-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_FIELD_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_FIELD_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/field.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value_iterator-inl.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\n// clang 6 does not think the default constructor can be noexcept, so we make it explicit\nsimdjson_inline field::field() noexcept : std::pair<raw_json_string, ondemand::value>() {}\n\nsimdjson_inline field::field(raw_json_string key, ondemand::value &&value) noexcept\n : std::pair<raw_json_string, ondemand::value>(key, std::forward<ondemand::value>(value))\n{\n}\n\nsimdjson_inline simdjson_result<field> field::start(value_iterator &parent_iter) noexcept {\n raw_json_string key;\n SIMDJSON_TRY( parent_iter.field_key().get(key) );\n SIMDJSON_TRY( parent_iter.field_value() );\n return field::start(parent_iter, key);\n}\n\nsimdjson_inline simdjson_result<field> field::start(const value_iterator &parent_iter, raw_json_string key) noexcept {\n return field(key, parent_iter.child());\n}\n\nsimdjson_inline simdjson_warn_unused simdjson_result<std::string_view> field::unescaped_key(bool allow_replacement) noexcept {\n SIMDJSON_ASSUME(first.buf != nullptr); // We would like to call .alive() but Visual Studio won't let us.\n simdjson_result<std::string_view> answer = first.unescape(second.iter.json_iter(), allow_replacement);\n first.consume();\n return answer;\n}\n\ntemplate <typename string_type>\nsimdjson_inline simdjson_warn_unused error_code field::unescaped_key(string_type& receiver, bool allow_replacement) noexcept {\n std::string_view key;\n SIMDJSON_TRY( unescaped_key(allow_replacement).get(key) );\n receiver = key;\n return SUCCESS;\n}\n\nsimdjson_inline raw_json_string field::key() const noexcept {\n SIMDJSON_ASSUME(first.buf != nullptr); // We would like to call .alive() by Visual Studio won't let us.\n return first;\n}\n\n\nsimdjson_inline std::string_view field::key_raw_json_token() const noexcept {\n SIMDJSON_ASSUME(first.buf != nullptr); // We would like to call .alive() by Visual Studio won't let us.\n return std::string_view(reinterpret_cast<const char*>(first.buf-1), second.iter._json_iter->token.peek(-1) - first.buf + 1);\n}\n\nsimdjson_inline std::string_view field::escaped_key() const noexcept {\n SIMDJSON_ASSUME(first.buf != nullptr); // We would like to call .alive() by Visual Studio won't let us.\n auto end_quote = second.iter._json_iter->token.peek(-1);\n while(*end_quote != '\"') end_quote--;\n return std::string_view(reinterpret_cast<const char*>(first.buf), end_quote - first.buf);\n}\n\nsimdjson_inline value &field::value() & noexcept {\n return second;\n}\n\nsimdjson_inline value field::value() && noexcept {\n return std::forward<field>(*this).second;\n}\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::field>::simdjson_result(\n lasx::ondemand::field &&value\n) noexcept :\n implementation_simdjson_result_base<lasx::ondemand::field>(\n std::forward<lasx::ondemand::field>(value)\n )\n{\n}\nsimdjson_inline simdjson_result<lasx::ondemand::field>::simdjson_result(\n error_code error\n) noexcept :\n implementation_simdjson_result_base<lasx::ondemand::field>(error)\n{\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::raw_json_string> simdjson_result<lasx::ondemand::field>::key() noexcept {\n if (error()) { return error(); }\n return first.key();\n}\n\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::field>::key_raw_json_token() noexcept {\n if (error()) { return error(); }\n return first.key_raw_json_token();\n}\n\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::field>::escaped_key() noexcept {\n if (error()) { return error(); }\n return first.escaped_key();\n}\n\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::field>::unescaped_key(bool allow_replacement) noexcept {\n if (error()) { return error(); }\n return first.unescaped_key(allow_replacement);\n}\n\ntemplate<typename string_type>\nsimdjson_warn_unused simdjson_inline error_code simdjson_result<lasx::ondemand::field>::unescaped_key(string_type &receiver, bool allow_replacement) noexcept {\n if (error()) { return error(); }\n return first.unescaped_key(receiver, allow_replacement);\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::field>::value() noexcept {\n if (error()) { return error(); }\n return std::move(first.value());\n}\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_FIELD_INL_H\n/* end file simdjson/generic/ondemand/field-inl.h for lasx */\n/* including simdjson/generic/ondemand/json_iterator-inl.h for lasx: #include \"simdjson/generic/ondemand/json_iterator-inl.h\" */\n/* begin file simdjson/generic/ondemand/json_iterator-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_JSON_ITERATOR_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_JSON_ITERATOR_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/internal/dom_parser_implementation.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/parser.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/raw_json_string.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/logger-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/parser-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/token_iterator-inl.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\nsimdjson_inline json_iterator::json_iterator(json_iterator &&other) noexcept\n : token(std::forward<token_iterator>(other.token)),\n parser{other.parser},\n _string_buf_loc{other._string_buf_loc},\n error{other.error},\n _depth{other._depth},\n _root{other._root},\n _streaming{other._streaming}\n{\n other.parser = nullptr;\n}\nsimdjson_inline json_iterator &json_iterator::operator=(json_iterator &&other) noexcept {\n token = other.token;\n parser = other.parser;\n _string_buf_loc = other._string_buf_loc;\n error = other.error;\n _depth = other._depth;\n _root = other._root;\n _streaming = other._streaming;\n other.parser = nullptr;\n return *this;\n}\n\nsimdjson_inline json_iterator::json_iterator(const uint8_t *buf, ondemand::parser *_parser) noexcept\n : token(buf, &_parser->implementation->structural_indexes[0]),\n parser{_parser},\n _string_buf_loc{parser->string_buf.get()},\n _depth{1},\n _root{parser->implementation->structural_indexes.get()},\n _streaming{false}\n\n{\n logger::log_headers();\n#if SIMDJSON_CHECK_EOF\n assert_more_tokens();\n#endif\n}\n\n#ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON\nsimdjson_inline json_iterator::json_iterator(const uint8_t *buf, ondemand::parser *_parser, bool streaming) noexcept\n : token(buf, &_parser->implementation->structural_indexes[0]),\n parser{_parser},\n _string_buf_loc{parser->string_buf.get()},\n _depth{1},\n _root{parser->implementation->structural_indexes.get()},\n _streaming{streaming}\n\n{\n logger::log_headers();\n#if SIMDJSON_CHECK_EOF\n assert_more_tokens();\n#endif\n}\n#endif // SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON\n\ninline void json_iterator::rewind() noexcept {\n token.set_position( root_position() );\n logger::log_headers(); // We start again\n _string_buf_loc = parser->string_buf.get();\n _depth = 1;\n}\n\ninline bool json_iterator::balanced() const noexcept {\n token_iterator ti(token);\n int32_t count{0};\n ti.set_position( root_position() );\n while(ti.peek() <= peek_last()) {\n switch (*ti.return_current_and_advance())\n {\n case '[': case '{':\n count++;\n break;\n case ']': case '}':\n count--;\n break;\n default:\n break;\n }\n }\n return count == 0;\n}\n\n\n// GCC 7 warns when the first line of this function is inlined away into oblivion due to the caller\n// relating depth and parent_depth, which is a desired effect. The warning does not show up if the\n// skip_child() function is not marked inline).\nSIMDJSON_PUSH_DISABLE_WARNINGS\nSIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING\nsimdjson_warn_unused simdjson_inline error_code json_iterator::skip_child(depth_t parent_depth) noexcept {\n if (depth() <= parent_depth) { return SUCCESS; }\n switch (*return_current_and_advance()) {\n // TODO consider whether matching braces is a requirement: if non-matching braces indicates\n // *missing* braces, then future lookups are not in the object/arrays they think they are,\n // violating the rule \"validate enough structure that the user can be confident they are\n // looking at the right values.\"\n // PERF TODO we can eliminate the switch here with a lookup of how much to add to depth\n\n // For the first open array/object in a value, we've already incremented depth, so keep it the same\n // We never stop at colon, but if we did, it wouldn't affect depth\n case '[': case '{': case ':':\n logger::log_start_value(*this, \"skip\");\n break;\n // If there is a comma, we have just finished a value in an array/object, and need to get back in\n case ',':\n logger::log_value(*this, \"skip\");\n break;\n // ] or } means we just finished a value and need to jump out of the array/object\n case ']': case '}':\n logger::log_end_value(*this, \"skip\");\n _depth--;\n if (depth() <= parent_depth) { return SUCCESS; }\n#if SIMDJSON_CHECK_EOF\n // If there are no more tokens, the parent is incomplete.\n if (at_end()) { return report_error(INCOMPLETE_ARRAY_OR_OBJECT, \"Missing [ or { at start\"); }\n#endif // SIMDJSON_CHECK_EOF\n break;\n case '\"':\n if(*peek() == ':') {\n // We are at a key!!!\n // This might happen if you just started an object and you skip it immediately.\n // Performance note: it would be nice to get rid of this check as it is somewhat\n // expensive.\n // https://github.com/simdjson/simdjson/issues/1742\n logger::log_value(*this, \"key\");\n return_current_and_advance(); // eat up the ':'\n break; // important!!!\n }\n simdjson_fallthrough;\n // Anything else must be a scalar value\n default:\n // For the first scalar, we will have incremented depth already, so we decrement it here.\n logger::log_value(*this, \"skip\");\n _depth--;\n if (depth() <= parent_depth) { return SUCCESS; }\n break;\n }\n\n // Now that we've considered the first value, we only increment/decrement for arrays/objects\n while (position() < end_position()) {\n switch (*return_current_and_advance()) {\n case '[': case '{':\n logger::log_start_value(*this, \"skip\");\n _depth++;\n break;\n // TODO consider whether matching braces is a requirement: if non-matching braces indicates\n // *missing* braces, then future lookups are not in the object/arrays they think they are,\n // violating the rule \"validate enough structure that the user can be confident they are\n // looking at the right values.\"\n // PERF TODO we can eliminate the switch here with a lookup of how much to add to depth\n case ']': case '}':\n logger::log_end_value(*this, \"skip\");\n _depth--;\n if (depth() <= parent_depth) { return SUCCESS; }\n break;\n default:\n logger::log_value(*this, \"skip\", \"\");\n break;\n }\n }\n\n return report_error(TAPE_ERROR, \"not enough close braces\");\n}\n\nSIMDJSON_POP_DISABLE_WARNINGS\n\nsimdjson_inline bool json_iterator::at_root() const noexcept {\n return position() == root_position();\n}\n\nsimdjson_inline bool json_iterator::is_single_token() const noexcept {\n return parser->implementation->n_structural_indexes == 1;\n}\n\nsimdjson_inline bool json_iterator::streaming() const noexcept {\n return _streaming;\n}\n\nsimdjson_inline token_position json_iterator::root_position() const noexcept {\n return _root;\n}\n\nsimdjson_inline void json_iterator::assert_at_document_depth() const noexcept {\n SIMDJSON_ASSUME( _depth == 1 );\n}\n\nsimdjson_inline void json_iterator::assert_at_root() const noexcept {\n SIMDJSON_ASSUME( _depth == 1 );\n#ifndef SIMDJSON_CLANG_VISUAL_STUDIO\n // Under Visual Studio, the next SIMDJSON_ASSUME fails with: the argument\n // has side effects that will be discarded.\n SIMDJSON_ASSUME( token.position() == _root );\n#endif\n}\n\nsimdjson_inline void json_iterator::assert_more_tokens(uint32_t required_tokens) const noexcept {\n assert_valid_position(token._position + required_tokens - 1);\n}\n\nsimdjson_inline void json_iterator::assert_valid_position(token_position position) const noexcept {\n#ifndef SIMDJSON_CLANG_VISUAL_STUDIO\n SIMDJSON_ASSUME( position >= &parser->implementation->structural_indexes[0] );\n SIMDJSON_ASSUME( position < &parser->implementation->structural_indexes[parser->implementation->n_structural_indexes] );\n#else\n (void)position; // Suppress unused parameter warning\n#endif\n}\n\nsimdjson_inline bool json_iterator::at_end() const noexcept {\n return position() == end_position();\n}\nsimdjson_inline token_position json_iterator::end_position() const noexcept {\n uint32_t n_structural_indexes{parser->implementation->n_structural_indexes};\n return &parser->implementation->structural_indexes[n_structural_indexes];\n}\n\ninline std::string json_iterator::to_string() const noexcept {\n if( !is_alive() ) { return \"dead json_iterator instance\"; }\n const char * current_structural = reinterpret_cast<const char *>(token.peek());\n return std::string(\"json_iterator [ depth : \") + std::to_string(_depth)\n + std::string(\", structural : '\") + std::string(current_structural,1)\n + std::string(\"', offset : \") + std::to_string(token.current_offset())\n + std::string(\"', error : \") + error_message(error)\n + std::string(\" ]\");\n}\n\ninline simdjson_result<const char *> json_iterator::current_location() const noexcept {\n if (!is_alive()) { // Unrecoverable error\n if (!at_root()) {\n return reinterpret_cast<const char *>(token.peek(-1));\n } else {\n return reinterpret_cast<const char *>(token.peek());\n }\n }\n if (at_end()) {\n return OUT_OF_BOUNDS;\n }\n return reinterpret_cast<const char *>(token.peek());\n}\n\nsimdjson_inline bool json_iterator::is_alive() const noexcept {\n return parser;\n}\n\nsimdjson_inline void json_iterator::abandon() noexcept {\n parser = nullptr;\n _depth = 0;\n}\n\nsimdjson_inline const uint8_t *json_iterator::return_current_and_advance() noexcept {\n#if SIMDJSON_CHECK_EOF\n assert_more_tokens();\n#endif // SIMDJSON_CHECK_EOF\n return token.return_current_and_advance();\n}\n\nsimdjson_inline const uint8_t *json_iterator::unsafe_pointer() const noexcept {\n // deliberately done without safety guard:\n return token.peek();\n}\n\nsimdjson_inline const uint8_t *json_iterator::peek(int32_t delta) const noexcept {\n#if SIMDJSON_CHECK_EOF\n assert_more_tokens(delta+1);\n#endif // SIMDJSON_CHECK_EOF\n return token.peek(delta);\n}\n\nsimdjson_inline uint32_t json_iterator::peek_length(int32_t delta) const noexcept {\n#if SIMDJSON_CHECK_EOF\n assert_more_tokens(delta+1);\n#endif // #if SIMDJSON_CHECK_EOF\n return token.peek_length(delta);\n}\n\nsimdjson_inline const uint8_t *json_iterator::peek(token_position position) const noexcept {\n // todo: currently we require end-of-string buffering, but the following\n // assert_valid_position should be turned on if/when we lift that condition.\n // assert_valid_position(position);\n // This is almost surely related to SIMDJSON_CHECK_EOF but given that SIMDJSON_CHECK_EOF\n // is ON by default, we have no choice but to disable it for real with a comment.\n return token.peek(position);\n}\n\nsimdjson_inline uint32_t json_iterator::peek_length(token_position position) const noexcept {\n#if SIMDJSON_CHECK_EOF\n assert_valid_position(position);\n#endif // SIMDJSON_CHECK_EOF\n return token.peek_length(position);\n}\nsimdjson_inline uint32_t json_iterator::peek_root_length(token_position position) const noexcept {\n#if SIMDJSON_CHECK_EOF\n assert_valid_position(position);\n#endif // SIMDJSON_CHECK_EOF\n return token.peek_root_length(position);\n}\n\nsimdjson_inline token_position json_iterator::last_position() const noexcept {\n // The following line fails under some compilers...\n // SIMDJSON_ASSUME(parser->implementation->n_structural_indexes > 0);\n // since it has side-effects.\n uint32_t n_structural_indexes{parser->implementation->n_structural_indexes};\n SIMDJSON_ASSUME(n_structural_indexes > 0);\n return &parser->implementation->structural_indexes[n_structural_indexes - 1];\n}\nsimdjson_inline const uint8_t *json_iterator::peek_last() const noexcept {\n return token.peek(last_position());\n}\n\nsimdjson_inline void json_iterator::ascend_to(depth_t parent_depth) noexcept {\n SIMDJSON_ASSUME(parent_depth >= 0 && parent_depth < INT32_MAX - 1);\n SIMDJSON_ASSUME(_depth == parent_depth + 1);\n _depth = parent_depth;\n}\n\nsimdjson_inline void json_iterator::descend_to(depth_t child_depth) noexcept {\n SIMDJSON_ASSUME(child_depth >= 1 && child_depth < INT32_MAX);\n SIMDJSON_ASSUME(_depth == child_depth - 1);\n _depth = child_depth;\n}\n\nsimdjson_inline depth_t json_iterator::depth() const noexcept {\n return _depth;\n}\n\nsimdjson_inline uint8_t *&json_iterator::string_buf_loc() noexcept {\n return _string_buf_loc;\n}\n\nsimdjson_warn_unused simdjson_inline error_code json_iterator::report_error(error_code _error, const char *message) noexcept {\n SIMDJSON_ASSUME(_error != SUCCESS && _error != UNINITIALIZED && _error != INCORRECT_TYPE && _error != NO_SUCH_FIELD);\n logger::log_error(*this, message);\n error = _error;\n return error;\n}\n\nsimdjson_inline token_position json_iterator::position() const noexcept {\n return token.position();\n}\n\nsimdjson_inline simdjson_result<std::string_view> json_iterator::unescape(raw_json_string in, bool allow_replacement) noexcept {\n#if SIMDJSON_DEVELOPMENT_CHECKS\n auto result = parser->unescape(in, _string_buf_loc, allow_replacement);\n SIMDJSON_ASSUME(!parser->string_buffer_overflow(_string_buf_loc));\n return result;\n#else\n return parser->unescape(in, _string_buf_loc, allow_replacement);\n#endif\n}\n\nsimdjson_inline simdjson_result<std::string_view> json_iterator::unescape_wobbly(raw_json_string in) noexcept {\n#if SIMDJSON_DEVELOPMENT_CHECKS\n auto result = parser->unescape_wobbly(in, _string_buf_loc);\n SIMDJSON_ASSUME(!parser->string_buffer_overflow(_string_buf_loc));\n return result;\n#else\n return parser->unescape_wobbly(in, _string_buf_loc);\n#endif\n}\n\nsimdjson_inline void json_iterator::reenter_child(token_position position, depth_t child_depth) noexcept {\n SIMDJSON_ASSUME(child_depth >= 1 && child_depth < INT32_MAX);\n SIMDJSON_ASSUME(_depth == child_depth - 1);\n#if SIMDJSON_DEVELOPMENT_CHECKS\n#ifndef SIMDJSON_CLANG_VISUAL_STUDIO\n SIMDJSON_ASSUME(size_t(child_depth) < parser->max_depth());\n SIMDJSON_ASSUME(position >= parser->start_positions[child_depth]);\n#endif\n#endif\n token.set_position(position);\n _depth = child_depth;\n}\n\nsimdjson_warn_unused simdjson_inline error_code json_iterator::consume_character(char c) noexcept {\n if (*peek() == c) {\n return_current_and_advance();\n return SUCCESS;\n }\n return TAPE_ERROR;\n}\n\n#if SIMDJSON_DEVELOPMENT_CHECKS\n\nsimdjson_inline token_position json_iterator::start_position(depth_t depth) const noexcept {\n SIMDJSON_ASSUME(size_t(depth) < parser->max_depth());\n return size_t(depth) < parser->max_depth() ? parser->start_positions[depth] : 0;\n}\n\nsimdjson_inline void json_iterator::set_start_position(depth_t depth, token_position position) noexcept {\n SIMDJSON_ASSUME(size_t(depth) < parser->max_depth());\n if(size_t(depth) < parser->max_depth()) { parser->start_positions[depth] = position; }\n}\n\n#endif\n\n\nsimdjson_warn_unused simdjson_inline error_code json_iterator::optional_error(error_code _error, const char *message) noexcept {\n SIMDJSON_ASSUME(_error == INCORRECT_TYPE || _error == NO_SUCH_FIELD);\n logger::log_error(*this, message);\n return _error;\n}\n\n\nsimdjson_warn_unused simdjson_inline bool json_iterator::copy_to_buffer(const uint8_t *json, uint32_t max_len, uint8_t *tmpbuf, size_t N) noexcept {\n // This function is not expected to be called in performance-sensitive settings.\n // Let us guard against silly cases:\n if((N < max_len) || (N == 0)) { return false; }\n // Copy to the buffer.\n std::memcpy(tmpbuf, json, max_len);\n if(N > max_len) { // We pad whatever remains with ' '.\n std::memset(tmpbuf + max_len, ' ', N - max_len);\n }\n return true;\n}\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::json_iterator>::simdjson_result(lasx::ondemand::json_iterator &&value) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::json_iterator>(std::forward<lasx::ondemand::json_iterator>(value)) {}\nsimdjson_inline simdjson_result<lasx::ondemand::json_iterator>::simdjson_result(error_code error) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::json_iterator>(error) {}\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_JSON_ITERATOR_INL_H\n/* end file simdjson/generic/ondemand/json_iterator-inl.h for lasx */\n/* including simdjson/generic/ondemand/json_type-inl.h for lasx: #include \"simdjson/generic/ondemand/json_type-inl.h\" */\n/* begin file simdjson/generic/ondemand/json_type-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_JSON_TYPE_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_JSON_TYPE_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_type.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base-inl.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\ninline std::ostream& operator<<(std::ostream& out, json_type type) noexcept {\n switch (type) {\n case json_type::array: out << \"array\"; break;\n case json_type::object: out << \"object\"; break;\n case json_type::number: out << \"number\"; break;\n case json_type::string: out << \"string\"; break;\n case json_type::boolean: out << \"boolean\"; break;\n case json_type::null: out << \"null\"; break;\n default: SIMDJSON_UNREACHABLE();\n }\n return out;\n}\n\n#if SIMDJSON_EXCEPTIONS\ninline std::ostream& operator<<(std::ostream& out, simdjson_result<json_type> &type) noexcept(false) {\n return out << type.value();\n}\n#endif\n\n\n\nsimdjson_inline number_type number::get_number_type() const noexcept {\n return type;\n}\n\nsimdjson_inline bool number::is_uint64() const noexcept {\n return get_number_type() == number_type::unsigned_integer;\n}\n\nsimdjson_inline uint64_t number::get_uint64() const noexcept {\n return payload.unsigned_integer;\n}\n\nsimdjson_inline number::operator uint64_t() const noexcept {\n return get_uint64();\n}\n\nsimdjson_inline bool number::is_int64() const noexcept {\n return get_number_type() == number_type::signed_integer;\n}\n\nsimdjson_inline int64_t number::get_int64() const noexcept {\n return payload.signed_integer;\n}\n\nsimdjson_inline number::operator int64_t() const noexcept {\n return get_int64();\n}\n\nsimdjson_inline bool number::is_double() const noexcept {\n return get_number_type() == number_type::floating_point_number;\n}\n\nsimdjson_inline double number::get_double() const noexcept {\n return payload.floating_point_number;\n}\n\nsimdjson_inline number::operator double() const noexcept {\n return get_double();\n}\n\nsimdjson_inline double number::as_double() const noexcept {\n if(is_double()) {\n return payload.floating_point_number;\n }\n if(is_int64()) {\n return double(payload.signed_integer);\n }\n return double(payload.unsigned_integer);\n}\n\nsimdjson_inline void number::append_s64(int64_t value) noexcept {\n payload.signed_integer = value;\n type = number_type::signed_integer;\n}\n\nsimdjson_inline void number::append_u64(uint64_t value) noexcept {\n payload.unsigned_integer = value;\n type = number_type::unsigned_integer;\n}\n\nsimdjson_inline void number::append_double(double value) noexcept {\n payload.floating_point_number = value;\n type = number_type::floating_point_number;\n}\n\nsimdjson_inline void number::skip_double() noexcept {\n type = number_type::floating_point_number;\n}\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::json_type>::simdjson_result(lasx::ondemand::json_type &&value) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::json_type>(std::forward<lasx::ondemand::json_type>(value)) {}\nsimdjson_inline simdjson_result<lasx::ondemand::json_type>::simdjson_result(error_code error) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::json_type>(error) {}\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_JSON_TYPE_INL_H\n/* end file simdjson/generic/ondemand/json_type-inl.h for lasx */\n/* including simdjson/generic/ondemand/logger-inl.h for lasx: #include \"simdjson/generic/ondemand/logger-inl.h\" */\n/* begin file simdjson/generic/ondemand/logger-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_LOGGER_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_LOGGER_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/logger.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value_iterator.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\n#include <memory>\n#include <cstring>\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\nnamespace logger {\n\nstatic constexpr const char * DASHES = \"----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\";\nstatic constexpr const int LOG_EVENT_LEN = 20;\nstatic constexpr const int LOG_BUFFER_LEN = 30;\nstatic constexpr const int LOG_SMALL_BUFFER_LEN = 10;\nstatic int log_depth = 0; // Not threadsafe. Log only.\n\n// Helper to turn unprintable or newline characters into spaces\nstatic inline char printable_char(char c) {\n if (c >= 0x20) {\n return c;\n } else {\n return ' ';\n }\n}\n\ntemplate<typename... Args>\nstatic inline std::string string_format(const std::string& format, const Args&... args)\n{\n SIMDJSON_PUSH_DISABLE_ALL_WARNINGS\n int size_s = std::snprintf(nullptr, 0, format.c_str(), args...) + 1;\n auto size = static_cast<size_t>(size_s);\n if (size <= 0) return std::string();\n std::unique_ptr<char[]> buf(new char[size]);\n std::snprintf(buf.get(), size, format.c_str(), args...);\n SIMDJSON_POP_DISABLE_WARNINGS\n return std::string(buf.get(), buf.get() + size - 1);\n}\n\nstatic inline log_level get_log_level_from_env()\n{\n SIMDJSON_PUSH_DISABLE_WARNINGS\n SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe\n char *lvl = getenv(\"SIMDJSON_LOG_LEVEL\");\n SIMDJSON_POP_DISABLE_WARNINGS\n if (lvl && simdjson_strcasecmp(lvl, \"ERROR\") == 0) { return log_level::error; }\n return log_level::info;\n}\n\nstatic inline log_level log_threshold()\n{\n static log_level threshold = get_log_level_from_env();\n return threshold;\n}\n\nstatic inline bool should_log(log_level level)\n{\n return level >= log_threshold();\n}\n\ninline void log_event(const json_iterator &iter, const char *type, std::string_view detail, int delta, int depth_delta) noexcept {\n log_line(iter, \"\", type, detail, delta, depth_delta, log_level::info);\n}\n\ninline void log_value(const json_iterator &iter, token_position index, depth_t depth, const char *type, std::string_view detail) noexcept {\n log_line(iter, index, depth, \"\", type, detail, log_level::info);\n}\ninline void log_value(const json_iterator &iter, const char *type, std::string_view detail, int delta, int depth_delta) noexcept {\n log_line(iter, \"\", type, detail, delta, depth_delta, log_level::info);\n}\n\ninline void log_start_value(const json_iterator &iter, token_position index, depth_t depth, const char *type, std::string_view detail) noexcept {\n log_line(iter, index, depth, \"+\", type, detail, log_level::info);\n if (LOG_ENABLED) { log_depth++; }\n}\ninline void log_start_value(const json_iterator &iter, const char *type, int delta, int depth_delta) noexcept {\n log_line(iter, \"+\", type, \"\", delta, depth_delta, log_level::info);\n if (LOG_ENABLED) { log_depth++; }\n}\n\ninline void log_end_value(const json_iterator &iter, const char *type, int delta, int depth_delta) noexcept {\n if (LOG_ENABLED) { log_depth--; }\n log_line(iter, \"-\", type, \"\", delta, depth_delta, log_level::info);\n}\n\ninline void log_error(const json_iterator &iter, const char *error, const char *detail, int delta, int depth_delta) noexcept {\n log_line(iter, \"ERROR: \", error, detail, delta, depth_delta, log_level::error);\n}\ninline void log_error(const json_iterator &iter, token_position index, depth_t depth, const char *error, const char *detail) noexcept {\n log_line(iter, index, depth, \"ERROR: \", error, detail, log_level::error);\n}\n\ninline void log_event(const value_iterator &iter, const char *type, std::string_view detail, int delta, int depth_delta) noexcept {\n log_event(iter.json_iter(), type, detail, delta, depth_delta);\n}\n\ninline void log_value(const value_iterator &iter, const char *type, std::string_view detail, int delta, int depth_delta) noexcept {\n log_value(iter.json_iter(), type, detail, delta, depth_delta);\n}\n\ninline void log_start_value(const value_iterator &iter, const char *type, int delta, int depth_delta) noexcept {\n log_start_value(iter.json_iter(), type, delta, depth_delta);\n}\n\ninline void log_end_value(const value_iterator &iter, const char *type, int delta, int depth_delta) noexcept {\n log_end_value(iter.json_iter(), type, delta, depth_delta);\n}\n\ninline void log_error(const value_iterator &iter, const char *error, const char *detail, int delta, int depth_delta) noexcept {\n log_error(iter.json_iter(), error, detail, delta, depth_delta);\n}\n\ninline void log_headers() noexcept {\n if (LOG_ENABLED) {\n if (simdjson_unlikely(should_log(log_level::info))) {\n // Technically a static variable is not thread-safe, but if you are using threads and logging... well...\n static bool displayed_hint{false};\n log_depth = 0;\n printf(\"\\n\");\n if (!displayed_hint) {\n // We only print this helpful header once.\n printf(\"# Logging provides the depth and position of the iterator user-visible steps:\\n\");\n printf(\"# +array says 'this is where we were when we discovered the start array'\\n\");\n printf(\n \"# -array says 'this is where we were when we ended the array'\\n\");\n printf(\"# skip says 'this is a structural or value I am skipping'\\n\");\n printf(\"# +/-skip says 'this is a start/end array or object I am skipping'\\n\");\n printf(\"#\\n\");\n printf(\"# The indentation of the terms (array, string,...) indicates the depth,\\n\");\n printf(\"# in addition to the depth being displayed.\\n\");\n printf(\"#\\n\");\n printf(\"# Every token in the document has a single depth determined by the tokens before it,\\n\");\n printf(\"# and is not affected by what the token actually is.\\n\");\n printf(\"#\\n\");\n printf(\"# Not all structural elements are presented as tokens in the logs.\\n\");\n printf(\"#\\n\");\n printf(\"# We never give control to the user within an empty array or an empty object.\\n\");\n printf(\"#\\n\");\n printf(\"# Inside an array, having a depth greater than the array's depth means that\\n\");\n printf(\"# we are pointing inside a value.\\n\");\n printf(\"# Having a depth equal to the array means that we are pointing right before a value.\\n\");\n printf(\"# Having a depth smaller than the array means that we have moved beyond the array.\\n\");\n displayed_hint = true;\n }\n printf(\"\\n\");\n printf(\"| %-*s \", LOG_EVENT_LEN, \"Event\");\n printf(\"| %-*s \", LOG_BUFFER_LEN, \"Buffer\");\n printf(\"| %-*s \", LOG_SMALL_BUFFER_LEN, \"Next\");\n // printf(\"| %-*s \", 5, \"Next#\");\n printf(\"| %-*s \", 5, \"Depth\");\n printf(\"| Detail \");\n printf(\"|\\n\");\n\n printf(\"|%.*s\", LOG_EVENT_LEN + 2, DASHES);\n printf(\"|%.*s\", LOG_BUFFER_LEN + 2, DASHES);\n printf(\"|%.*s\", LOG_SMALL_BUFFER_LEN + 2, DASHES);\n // printf(\"|%.*s\", 5+2, DASHES);\n printf(\"|%.*s\", 5 + 2, DASHES);\n printf(\"|--------\");\n printf(\"|\\n\");\n fflush(stdout);\n }\n }\n}\n\ntemplate <typename... Args>\ninline void log_line(const json_iterator &iter, const char *title_prefix, const char *title, std::string_view detail, int delta, int depth_delta, log_level level, Args&&... args) noexcept {\n log_line(iter, iter.position()+delta, depth_t(iter.depth()+depth_delta), title_prefix, title, detail, level, std::forward<Args>(args)...);\n}\n\ntemplate <typename... Args>\ninline void log_line(const json_iterator &iter, token_position index, depth_t depth, const char *title_prefix, const char *title, std::string_view detail, log_level level, Args&&... args) noexcept {\n if (LOG_ENABLED) {\n if (simdjson_unlikely(should_log(level))) {\n const int indent = depth * 2;\n const auto buf = iter.token.buf;\n auto msg = string_format(title, std::forward<Args>(args)...);\n printf(\"| %*s%s%-*s \", indent, \"\", title_prefix,\n LOG_EVENT_LEN - indent - int(strlen(title_prefix)), msg.c_str());\n {\n // Print the current structural.\n printf(\"| \");\n // Before we begin, the index might point right before the document.\n // This could be unsafe, see https://github.com/simdjson/simdjson/discussions/1938\n if (index < iter._root) {\n printf(\"%*s\", LOG_BUFFER_LEN, \"\");\n } else {\n auto current_structural = &buf[*index];\n for (int i = 0; i < LOG_BUFFER_LEN; i++) {\n printf(\"%c\", printable_char(current_structural[i]));\n }\n }\n printf(\" \");\n }\n {\n // Print the next structural.\n printf(\"| \");\n auto next_structural = &buf[*(index + 1)];\n for (int i = 0; i < LOG_SMALL_BUFFER_LEN; i++) {\n printf(\"%c\", printable_char(next_structural[i]));\n }\n printf(\" \");\n }\n // printf(\"| %5u \", *(index+1));\n printf(\"| %5i \", depth);\n printf(\"| %6.*s \", int(detail.size()), detail.data());\n printf(\"|\\n\");\n fflush(stdout);\n }\n }\n}\n\n} // namespace logger\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_LOGGER_INL_H\n/* end file simdjson/generic/ondemand/logger-inl.h for lasx */\n/* including simdjson/generic/ondemand/object-inl.h for lasx: #include \"simdjson/generic/ondemand/object-inl.h\" */\n/* begin file simdjson/generic/ondemand/object-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_OBJECT_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_OBJECT_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/field.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/object.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/object_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/raw_json_string.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/jsonpathutil.h\" */\n/* amalgamation skipped (editor-only): #if SIMDJSON_STATIC_REFLECTION */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_string_builder.h\" // for constevalutil::fixed_string */\n/* amalgamation skipped (editor-only): #include <meta> */\n/* amalgamation skipped (editor-only): #endif */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\nsimdjson_inline simdjson_result<value> object::find_field_unordered(const std::string_view key) & noexcept {\n bool has_value;\n SIMDJSON_TRY( iter.find_field_unordered_raw(key).get(has_value) );\n if (!has_value) {\n logger::log_line(iter.json_iter(), \"ERROR: \", \"Cannot find key %.*s\", \"\", -1, 0, logger::log_level::error, static_cast<int>(key.size()), key.data());\n return NO_SUCH_FIELD;\n }\n return value(iter.child());\n}\nsimdjson_inline simdjson_result<value> object::find_field_unordered(const std::string_view key) && noexcept {\n bool has_value;\n SIMDJSON_TRY( iter.find_field_unordered_raw(key).get(has_value) );\n if (!has_value) {\n logger::log_line(iter.json_iter(), \"ERROR: \", \"Cannot find key %.*s\", \"\", -1, 0, logger::log_level::error, static_cast<int>(key.size()), key.data());\n return NO_SUCH_FIELD;\n }\n return value(iter.child());\n}\nsimdjson_inline simdjson_result<value> object::operator[](const std::string_view key) & noexcept {\n return find_field_unordered(key);\n}\nsimdjson_inline simdjson_result<value> object::operator[](const std::string_view key) && noexcept {\n return std::forward<object>(*this).find_field_unordered(key);\n}\nsimdjson_inline simdjson_result<value> object::find_field(const std::string_view key) & noexcept {\n bool has_value;\n SIMDJSON_TRY( iter.find_field_raw(key).get(has_value) );\n if (!has_value) {\n logger::log_line(iter.json_iter(), \"ERROR: \", \"Cannot find key %.*s\", \"\", -1, 0, logger::log_level::error, static_cast<int>(key.size()), key.data());\n return NO_SUCH_FIELD;\n }\n return value(iter.child());\n}\nsimdjson_inline simdjson_result<value> object::find_field(const std::string_view key) && noexcept {\n bool has_value;\n SIMDJSON_TRY( iter.find_field_raw(key).get(has_value) );\n if (!has_value) {\n logger::log_line(iter.json_iter(), \"ERROR: \", \"Cannot find key %.*s\", \"\", -1, 0, logger::log_level::error, static_cast<int>(key.size()), key.data());\n return NO_SUCH_FIELD;\n }\n return value(iter.child());\n}\n\nsimdjson_inline simdjson_result<object> object::start(value_iterator &iter) noexcept {\n SIMDJSON_TRY( iter.start_object().error() );\n return object(iter);\n}\nsimdjson_inline simdjson_result<object> object::start_root(value_iterator &iter) noexcept {\n SIMDJSON_TRY( iter.start_root_object().error() );\n return object(iter);\n}\nsimdjson_warn_unused simdjson_inline error_code object::consume() noexcept {\n if(iter.is_at_key()) {\n /**\n * whenever you are pointing at a key, calling skip_child() is\n * unsafe because you will hit a string and you will assume that\n * it is string value, and this mistake will lead you to make bad\n * depth computation.\n */\n /**\n * We want to 'consume' the key. We could really\n * just do _json_iter->return_current_and_advance(); at this\n * point, but, for clarity, we will use the high-level API to\n * eat the key. We assume that the compiler optimizes away\n * most of the work.\n */\n simdjson_unused raw_json_string actual_key;\n auto error = iter.field_key().get(actual_key);\n if (error) { iter.abandon(); return error; };\n // Let us move to the value while we are at it.\n if ((error = iter.field_value())) { iter.abandon(); return error; }\n }\n auto error_skip = iter.json_iter().skip_child(iter.depth()-1);\n if(error_skip) { iter.abandon(); }\n return error_skip;\n}\n\nsimdjson_inline simdjson_result<std::string_view> object::raw_json() noexcept {\n const uint8_t * starting_point{iter.peek_start()};\n auto error = consume();\n if(error) { return error; }\n const uint8_t * final_point{iter._json_iter->peek()};\n return std::string_view(reinterpret_cast<const char*>(starting_point), size_t(final_point - starting_point));\n}\n\nsimdjson_inline simdjson_result<object> object::started(value_iterator &iter) noexcept {\n SIMDJSON_TRY( iter.started_object().error() );\n return object(iter);\n}\n\nsimdjson_inline object object::resume(const value_iterator &iter) noexcept {\n return iter;\n}\n\nsimdjson_inline object::object(const value_iterator &_iter) noexcept\n : iter{_iter}\n{\n}\n\nsimdjson_inline simdjson_result<object_iterator> object::begin() noexcept {\n#if SIMDJSON_DEVELOPMENT_CHECKS\n if (!iter.is_at_iterator_start()) { return OUT_OF_ORDER_ITERATION; }\n#endif\n return object_iterator(iter);\n}\nsimdjson_inline simdjson_result<object_iterator> object::end() noexcept {\n return object_iterator(iter);\n}\n\ninline simdjson_result<value> object::at_pointer(std::string_view json_pointer) noexcept {\n if (json_pointer[0] != '/') { return INVALID_JSON_POINTER; }\n json_pointer = json_pointer.substr(1);\n size_t slash = json_pointer.find('/');\n std::string_view key = json_pointer.substr(0, slash);\n // Grab the child with the given key\n simdjson_result<value> child;\n\n // If there is an escape character in the key, unescape it and then get the child.\n size_t escape = key.find('~');\n if (escape != std::string_view::npos) {\n // Unescape the key\n std::string unescaped(key);\n do {\n switch (unescaped[escape+1]) {\n case '0':\n unescaped.replace(escape, 2, \"~\");\n break;\n case '1':\n unescaped.replace(escape, 2, \"/\");\n break;\n default:\n return INVALID_JSON_POINTER; // \"Unexpected ~ escape character in JSON pointer\");\n }\n escape = unescaped.find('~', escape+1);\n } while (escape != std::string::npos);\n child = find_field(unescaped); // Take note find_field does not unescape keys when matching\n } else {\n child = find_field(key);\n }\n if(child.error()) {\n return child; // we do not continue if there was an error\n }\n // If there is a /, we have to recurse and look up more of the path\n if (slash != std::string_view::npos) {\n child = child.at_pointer(json_pointer.substr(slash));\n }\n return child;\n}\n\ninline simdjson_result<value> object::at_path(std::string_view json_path) noexcept {\n auto json_pointer = json_path_to_pointer_conversion(json_path);\n if (json_pointer == \"-1\") {\n return INVALID_JSON_POINTER;\n }\n return at_pointer(json_pointer);\n}\n\ninline simdjson_result<std::vector<value>> object::at_path_with_wildcard(std::string_view json_path) noexcept {\n std::vector<value> result;\n\n auto result_pair = get_next_key_and_json_path(json_path);\n std::string_view key = result_pair.first;\n std::string_view remaining_path = result_pair.second;\n // Handle when its the case for wildcard\n if (key == \"*\") {\n // Loop through each field in the object\n for (auto field : *this) {\n value val;\n SIMDJSON_TRY(field.value().get(val));\n\n if (remaining_path.empty()) {\n result.push_back(std::move(val));\n } else {\n auto nested_result = val.at_path_with_wildcard(remaining_path);\n\n if (nested_result.error()) {\n return nested_result.error();\n }\n // Extract and append all nested matches to our result\n std::vector<value> nested_vec;\n SIMDJSON_TRY(std::move(nested_result).get(nested_vec));\n\n result.insert(result.end(),\n std::make_move_iterator(nested_vec.begin()),\n std::make_move_iterator(nested_vec.end()));\n }\n }\n return result;\n } else {\n value val;\n SIMDJSON_TRY(find_field(key).get(val));\n\n if (remaining_path.empty()) {\n result.push_back(std::move(val));\n return result;\n } else {\n return val.at_path_with_wildcard(remaining_path);\n }\n }\n}\n\nsimdjson_inline simdjson_result<size_t> object::count_fields() & noexcept {\n size_t count{0};\n // Important: we do not consume any of the values.\n for(simdjson_unused auto v : *this) { count++; }\n // The above loop will always succeed, but we want to report errors.\n if(iter.error()) { return iter.error(); }\n // We need to move back at the start because we expect users to iterate through\n // the object after counting the number of elements.\n iter.reset_object();\n return count;\n}\n\nsimdjson_inline simdjson_result<bool> object::is_empty() & noexcept {\n bool is_not_empty;\n auto error = iter.reset_object().get(is_not_empty);\n if(error) { return error; }\n return !is_not_empty;\n}\n\nsimdjson_inline simdjson_result<bool> object::reset() & noexcept {\n return iter.reset_object();\n}\n\n#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION\n\ntemplate<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\nsimdjson_warn_unused simdjson_inline error_code object::extract_into(T& out) & noexcept {\n // Helper to check if a field name matches any of the requested fields\n auto should_extract = [](std::string_view field_name) constexpr -> bool {\n return ((FieldNames.view() == field_name) || ...);\n };\n\n // Iterate through all members of T using reflection\n template for (constexpr auto mem : std::define_static_array(\n std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {\n\n if constexpr (!std::meta::is_const(mem) && std::meta::is_public(mem)) {\n constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));\n\n // Only extract this field if it's in our list of requested fields\n if constexpr (should_extract(key)) {\n // Try to find and extract the field\n if constexpr (concepts::optional_type<decltype(out.[:mem:])>) {\n // For optional fields, it's ok if they're missing\n auto field_result = find_field_unordered(key);\n if (!field_result.error()) {\n auto error = field_result.get(out.[:mem:]);\n if (error && error != NO_SUCH_FIELD) {\n return error;\n }\n } else if (field_result.error() != NO_SUCH_FIELD) {\n return field_result.error();\n } else {\n out.[:mem:].reset();\n }\n } else {\n // For required fields (in the requested list), fail if missing\n SIMDJSON_TRY((*this)[key].get(out.[:mem:]));\n }\n }\n }\n };\n\n return SUCCESS;\n}\n\n#endif // SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::object>::simdjson_result(lasx::ondemand::object &&value) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::object>(std::forward<lasx::ondemand::object>(value)) {}\nsimdjson_inline simdjson_result<lasx::ondemand::object>::simdjson_result(error_code error) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::object>(error) {}\n\nsimdjson_inline simdjson_result<lasx::ondemand::object_iterator> simdjson_result<lasx::ondemand::object>::begin() noexcept {\n if (error()) { return error(); }\n return first.begin();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::object_iterator> simdjson_result<lasx::ondemand::object>::end() noexcept {\n if (error()) { return error(); }\n return first.end();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::find_field_unordered(std::string_view key) & noexcept {\n if (error()) { return error(); }\n return first.find_field_unordered(key);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::find_field_unordered(std::string_view key) && noexcept {\n if (error()) { return error(); }\n return std::forward<lasx::ondemand::object>(first).find_field_unordered(key);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::operator[](std::string_view key) & noexcept {\n if (error()) { return error(); }\n return first[key];\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::operator[](std::string_view key) && noexcept {\n if (error()) { return error(); }\n return std::forward<lasx::ondemand::object>(first)[key];\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::find_field(std::string_view key) & noexcept {\n if (error()) { return error(); }\n return first.find_field(key);\n}\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::find_field(std::string_view key) && noexcept {\n if (error()) { return error(); }\n return std::forward<lasx::ondemand::object>(first).find_field(key);\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::at_pointer(std::string_view json_pointer) noexcept {\n if (error()) { return error(); }\n return first.at_pointer(json_pointer);\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::at_path(\n std::string_view json_path) noexcept {\n if (error()) {\n return error();\n }\n return first.at_path(json_path);\n}\n\nsimdjson_inline simdjson_result<std::vector<lasx::ondemand::value>> simdjson_result<lasx::ondemand::object>::at_path_with_wildcard(std::string_view json_path) noexcept {\n if (error()) { return error(); }\n return first.at_path_with_wildcard(json_path);\n}\n\ninline simdjson_result<bool> simdjson_result<lasx::ondemand::object>::reset() noexcept {\n if (error()) { return error(); }\n return first.reset();\n}\n\ninline simdjson_result<bool> simdjson_result<lasx::ondemand::object>::is_empty() noexcept {\n if (error()) { return error(); }\n return first.is_empty();\n}\n\nsimdjson_inline simdjson_result<size_t> simdjson_result<lasx::ondemand::object>::count_fields() & noexcept {\n if (error()) { return error(); }\n return first.count_fields();\n}\n\nsimdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::object>::raw_json() noexcept {\n if (error()) { return error(); }\n return first.raw_json();\n}\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_INL_H\n/* end file simdjson/generic/ondemand/object-inl.h for lasx */\n/* including simdjson/generic/ondemand/object_iterator-inl.h for lasx: #include \"simdjson/generic/ondemand/object_iterator-inl.h\" */\n/* begin file simdjson/generic/ondemand/object_iterator-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/object_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/field-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value_iterator-inl.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\n//\n// object_iterator\n//\n\nsimdjson_inline object_iterator::object_iterator(const value_iterator &_iter) noexcept\n : iter{_iter}\n{}\n\nsimdjson_inline simdjson_result<field> object_iterator::operator*() noexcept {\n error_code error = iter.error();\n if (error) { iter.abandon(); return error; }\n auto result = field::start(iter);\n // TODO this is a safety rail ... users should exit loops as soon as they receive an error.\n // Nonetheless, let's see if performance is OK with this if statement--the compiler may give it to us for free.\n if (result.error()) { iter.abandon(); }\n return result;\n}\nsimdjson_inline bool object_iterator::operator==(const object_iterator &other) const noexcept {\n return !(*this != other);\n}\nsimdjson_inline bool object_iterator::operator!=(const object_iterator &) const noexcept {\n return iter.is_open();\n}\n\nSIMDJSON_PUSH_DISABLE_WARNINGS\nSIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING\nsimdjson_inline object_iterator &object_iterator::operator++() noexcept {\n // TODO this is a safety rail ... users should exit loops as soon as they receive an error.\n // Nonetheless, let's see if performance is OK with this if statement--the compiler may give it to us for free.\n if (!iter.is_open()) { return *this; } // Iterator will be released if there is an error\n\n simdjson_unused error_code error;\n if ((error = iter.skip_child() )) { return *this; }\n\n simdjson_unused bool has_value;\n if ((error = iter.has_next_field().get(has_value) )) { return *this; };\n return *this;\n}\nSIMDJSON_POP_DISABLE_WARNINGS\n\n//\n// ### Live States\n//\n// While iterating or looking up values, depth >= iter.depth. at_start may vary. Error is\n// always SUCCESS:\n//\n// - Start: This is the state when the object is first found and the iterator is just past the {.\n// In this state, at_start == true.\n// - Next: After we hand a scalar value to the user, or an array/object which they then fully\n// iterate over, the iterator is at the , or } before the next value. In this state,\n// depth == iter.depth, at_start == false, and error == SUCCESS.\n// - Unfinished Business: When we hand an array/object to the user which they do not fully\n// iterate over, we need to finish that iteration by skipping child values until we reach the\n// Next state. In this state, depth > iter.depth, at_start == false, and error == SUCCESS.\n//\n// ## Error States\n//\n// In error states, we will yield exactly one more value before stopping. iter.depth == depth\n// and at_start is always false. We decrement after yielding the error, moving to the Finished\n// state.\n//\n// - Chained Error: When the object iterator is part of an error chain--for example, in\n// `for (auto tweet : doc[\"tweets\"])`, where the tweet field may be missing or not be an\n// object--we yield that error in the loop, exactly once. In this state, error != SUCCESS and\n// iter.depth == depth, and at_start == false. We decrement depth when we yield the error.\n// - Missing Comma Error: When the iterator ++ method discovers there is no comma between fields,\n// we flag that as an error and treat it exactly the same as a Chained Error. In this state,\n// error == TAPE_ERROR, iter.depth == depth, and at_start == false.\n//\n// Errors that occur while reading a field to give to the user (such as when the key is not a\n// string or the field is missing a colon) are yielded immediately. Depth is then decremented,\n// moving to the Finished state without transitioning through an Error state at all.\n//\n// ## Terminal State\n//\n// The terminal state has iter.depth < depth. at_start is always false.\n//\n// - Finished: When we have reached a }, we are finished. We signal this by decrementing depth.\n// In this state, iter.depth < depth, at_start == false, and error == SUCCESS.\n//\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::object_iterator>::simdjson_result(\n lasx::ondemand::object_iterator &&value\n) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::object_iterator>(std::forward<lasx::ondemand::object_iterator>(value))\n{\n first.iter.assert_is_valid();\n}\nsimdjson_inline simdjson_result<lasx::ondemand::object_iterator>::simdjson_result(error_code error) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::object_iterator>({}, error)\n{\n}\n\nsimdjson_inline simdjson_result<lasx::ondemand::field> simdjson_result<lasx::ondemand::object_iterator>::operator*() noexcept {\n if (error()) { return error(); }\n return *first;\n}\n// If we're iterating and there is an error, return the error once.\nsimdjson_inline bool simdjson_result<lasx::ondemand::object_iterator>::operator==(const simdjson_result<lasx::ondemand::object_iterator> &other) const noexcept {\n if (!first.iter.is_valid()) { return !error(); }\n return first == other.first;\n}\n// If we're iterating and there is an error, return the error once.\nsimdjson_inline bool simdjson_result<lasx::ondemand::object_iterator>::operator!=(const simdjson_result<lasx::ondemand::object_iterator> &other) const noexcept {\n if (!first.iter.is_valid()) { return error(); }\n return first != other.first;\n}\n// Checks for ']' and ','\nsimdjson_inline simdjson_result<lasx::ondemand::object_iterator> &simdjson_result<lasx::ondemand::object_iterator>::operator++() noexcept {\n // Clear the error if there is one, so we don't yield it twice\n if (error()) { second = SUCCESS; return *this; }\n ++first;\n return *this;\n}\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_INL_H\n/* end file simdjson/generic/ondemand/object_iterator-inl.h for lasx */\n/* including simdjson/generic/ondemand/parser-inl.h for lasx: #include \"simdjson/generic/ondemand/parser-inl.h\" */\n/* begin file simdjson/generic/ondemand/parser-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/padded_string.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/padded_string_view.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/implementation.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/internal/dom_parser_implementation.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/dom/base.h\" // for MINIMAL_DOCUMENT_CAPACITY */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/document_stream.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/parser.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/raw_json_string.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\nsimdjson_inline parser::parser(size_t max_capacity) noexcept\n : _max_capacity{max_capacity} {\n}\n\nsimdjson_warn_unused simdjson_inline error_code parser::allocate(size_t new_capacity, size_t new_max_depth) noexcept {\n if (new_capacity > max_capacity()) { return CAPACITY; }\n if (string_buf && new_capacity == capacity() && new_max_depth == max_depth()) { return SUCCESS; }\n\n // string_capacity copied from document::allocate\n _capacity = 0;\n size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + SIMDJSON_PADDING, 64);\n string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);\n#if SIMDJSON_DEVELOPMENT_CHECKS\n start_positions.reset(new (std::nothrow) token_position[new_max_depth]);\n#endif\n if (implementation) {\n SIMDJSON_TRY( implementation->set_capacity(new_capacity) );\n SIMDJSON_TRY( implementation->set_max_depth(new_max_depth) );\n } else {\n SIMDJSON_TRY( simdjson::get_active_implementation()->create_dom_parser_implementation(new_capacity, new_max_depth, implementation) );\n }\n _capacity = new_capacity;\n _max_depth = new_max_depth;\n return SUCCESS;\n}\n#if SIMDJSON_DEVELOPMENT_CHECKS\nsimdjson_inline simdjson_warn_unused bool parser::string_buffer_overflow(const uint8_t *string_buf_loc) const noexcept {\n return (string_buf_loc < string_buf.get()) || (size_t(string_buf_loc - string_buf.get()) >= capacity());\n}\n#endif\n\nsimdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(padded_string_view json) & noexcept {\n if (!json.has_sufficient_padding()) { return INSUFFICIENT_PADDING; }\n\n json.remove_utf8_bom();\n\n // Allocate if needed\n if (capacity() < json.length() || !string_buf) {\n SIMDJSON_TRY( allocate(json.length(), max_depth()) );\n }\n\n // Run stage 1.\n SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );\n return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this });\n}\n\n#ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON\nsimdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate_allow_incomplete_json(padded_string_view json) & noexcept {\n if (!json.has_sufficient_padding()) { return INSUFFICIENT_PADDING; }\n\n json.remove_utf8_bom();\n\n // Allocate if needed\n if (capacity() < json.length() || !string_buf) {\n SIMDJSON_TRY( allocate(json.length(), max_depth()) );\n }\n\n // Run stage 1.\n const simdjson::error_code err = implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular);\n if (err) {\n if (err != UNCLOSED_STRING)\n return err;\n }\n return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this, true });\n}\n#endif // SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON\n\nsimdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const char *json, size_t len, size_t allocated) & noexcept {\n return iterate(padded_string_view(json, len, allocated));\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const uint8_t *json, size_t len, size_t allocated) & noexcept {\n return iterate(padded_string_view(json, len, allocated));\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string_view json, size_t allocated) & noexcept {\n return iterate(padded_string_view(json, allocated));\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string &json) & noexcept {\n return iterate(pad_with_reserve(json));\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const std::string &json) & noexcept {\n return iterate(padded_string_view(json));\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string_view> &result) & noexcept {\n // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception\n SIMDJSON_TRY( result.error() );\n padded_string_view json = result.value_unsafe();\n return iterate(json);\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string> &result) & noexcept {\n // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception\n SIMDJSON_TRY( result.error() );\n const padded_string &json = result.value_unsafe();\n return iterate(json);\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<json_iterator> parser::iterate_raw(padded_string_view json) & noexcept {\n if (!json.has_sufficient_padding()) { return INSUFFICIENT_PADDING; }\n\n json.remove_utf8_bom();\n\n // Allocate if needed\n if (capacity() < json.length()) {\n SIMDJSON_TRY( allocate(json.length(), max_depth()) );\n }\n\n // Run stage 1.\n SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );\n return json_iterator(reinterpret_cast<const uint8_t *>(json.data()), this);\n}\n\ninline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {\n // Warning: no check is done on the buffer padding. We trust the user.\n if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }\n if((len >= 3) && (std::memcmp(buf, \"\\xEF\\xBB\\xBF\", 3) == 0)) {\n buf += 3;\n len -= 3;\n }\n if(allow_comma_separated && batch_size < len) { batch_size = len; }\n return document_stream(*this, buf, len, batch_size, allow_comma_separated);\n}\n\ninline simdjson_result<document_stream> parser::iterate_many(const char *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {\n // Warning: no check is done on the buffer padding. We trust the user.\n return iterate_many(reinterpret_cast<const uint8_t *>(buf), len, batch_size, allow_comma_separated);\n}\ninline simdjson_result<document_stream> parser::iterate_many(padded_string_view s, size_t batch_size, bool allow_comma_separated) noexcept {\n if (!s.has_sufficient_padding()) { return INSUFFICIENT_PADDING; }\n return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);\n}\ninline simdjson_result<document_stream> parser::iterate_many(const padded_string &s, size_t batch_size, bool allow_comma_separated) noexcept {\n return iterate_many(padded_string_view(s), batch_size, allow_comma_separated);\n}\ninline simdjson_result<document_stream> parser::iterate_many(const std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {\n return iterate_many(padded_string_view(s), batch_size, allow_comma_separated);\n}\ninline simdjson_result<document_stream> parser::iterate_many(std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {\n return iterate_many(pad(s), batch_size, allow_comma_separated);\n}\nsimdjson_pure simdjson_inline size_t parser::capacity() const noexcept {\n return _capacity;\n}\nsimdjson_pure simdjson_inline size_t parser::max_capacity() const noexcept {\n return _max_capacity;\n}\nsimdjson_pure simdjson_inline size_t parser::max_depth() const noexcept {\n return _max_depth;\n}\n\nsimdjson_inline void parser::set_max_capacity(size_t max_capacity) noexcept {\n if(max_capacity < dom::MINIMAL_DOCUMENT_CAPACITY) {\n _max_capacity = max_capacity;\n } else {\n _max_capacity = dom::MINIMAL_DOCUMENT_CAPACITY;\n }\n}\n\nsimdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape(raw_json_string in, uint8_t *&dst, bool allow_replacement) const noexcept {\n uint8_t *end = implementation->parse_string(in.buf, dst, allow_replacement);\n if (!end) { return STRING_ERROR; }\n std::string_view result(reinterpret_cast<const char *>(dst), end-dst);\n dst = end;\n return result;\n}\n\nsimdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape_wobbly(raw_json_string in, uint8_t *&dst) const noexcept {\n uint8_t *end = implementation->parse_wobbly_string(in.buf, dst);\n if (!end) { return STRING_ERROR; }\n std::string_view result(reinterpret_cast<const char *>(dst), end-dst);\n dst = end;\n return result;\n}\n\nsimdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() {\n return *parser::get_parser_instance();\n}\n\nsimdjson_inline bool release_parser() {\n auto &parser_instance = parser::get_threadlocal_parser_if_exists();\n if (parser_instance) {\n parser_instance.reset();\n return true;\n }\n return false;\n}\n\nsimdjson_inline simdjson_warn_unused std::unique_ptr<ondemand::parser>& parser::get_parser_instance() {\n std::unique_ptr<ondemand::parser>& parser_instance = get_threadlocal_parser_if_exists();\n if (!parser_instance) {\n parser_instance.reset(new ondemand::parser());\n }\n return parser_instance;\n}\n\nsimdjson_inline simdjson_warn_unused std::unique_ptr<ondemand::parser>& parser::get_threadlocal_parser_if_exists() {\n // @the-moisrex points out that this could be implemented with std::optional (C++17).\n thread_local std::unique_ptr<ondemand::parser> parser_instance = nullptr;\n return parser_instance;\n}\n\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::parser>::simdjson_result(lasx::ondemand::parser &&value) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::parser>(std::forward<lasx::ondemand::parser>(value)) {}\nsimdjson_inline simdjson_result<lasx::ondemand::parser>::simdjson_result(error_code error) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::parser>(error) {}\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H\n/* end file simdjson/generic/ondemand/parser-inl.h for lasx */\n/* including simdjson/generic/ondemand/raw_json_string-inl.h for lasx: #include \"simdjson/generic/ondemand/raw_json_string-inl.h\" */\n/* begin file simdjson/generic/ondemand/raw_json_string-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/raw_json_string.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_iterator-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base-inl.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\n\nnamespace lasx {\nnamespace ondemand {\n\nsimdjson_inline raw_json_string::raw_json_string(const uint8_t * _buf) noexcept : buf{_buf} {}\n\nsimdjson_inline const char * raw_json_string::raw() const noexcept {\n return reinterpret_cast<const char *>(buf);\n}\n\nsimdjson_inline char raw_json_string::operator[](size_t i) const noexcept {\n return reinterpret_cast<const char *>(buf)[i];\n}\n\nsimdjson_inline bool raw_json_string::is_free_from_unescaped_quote(std::string_view target) noexcept {\n size_t pos{0};\n while(pos < target.size()) {\n pos = target.find('\"', pos);\n if(pos == std::string_view::npos) { return true; }\n if(pos != 0 && target[pos-1] != '\\\\') { return false; }\n if(pos > 1 && target[pos-2] == '\\\\') {\n size_t backslash_count{2};\n for(size_t i = 3; i <= pos; i++) {\n if(target[pos-i] == '\\\\') { backslash_count++; }\n else { break; }\n }\n if(backslash_count % 2 == 0) { return false; }\n }\n pos++;\n }\n return true;\n}\n\nsimdjson_inline bool raw_json_string::is_free_from_unescaped_quote(const char* target) noexcept {\n size_t pos{0};\n while(target[pos]) {\n const char * result = strchr(target+pos, '\"');\n if(result == nullptr) { return true; }\n pos = result - target;\n if(pos != 0 && target[pos-1] != '\\\\') { return false; }\n if(pos > 1 && target[pos-2] == '\\\\') {\n size_t backslash_count{2};\n for(size_t i = 3; i <= pos; i++) {\n if(target[pos-i] == '\\\\') { backslash_count++; }\n else { break; }\n }\n if(backslash_count % 2 == 0) { return false; }\n }\n pos++;\n }\n return true;\n}\n\n\nsimdjson_inline bool raw_json_string::unsafe_is_equal(size_t length, std::string_view target) const noexcept {\n // If we are going to call memcmp, then we must know something about the length of the raw_json_string.\n return (length >= target.size()) && (raw()[target.size()] == '\"') && !memcmp(raw(), target.data(), target.size());\n}\n\nsimdjson_inline bool raw_json_string::unsafe_is_equal(std::string_view target) const noexcept {\n // Assumptions: does not contain unescaped quote characters(\"), and\n // the raw content is quote terminated within a valid JSON string.\n if(target.size() <= SIMDJSON_PADDING) {\n return (raw()[target.size()] == '\"') && !memcmp(raw(), target.data(), target.size());\n }\n const char * r{raw()};\n size_t pos{0};\n for(;pos < target.size();pos++) {\n if(r[pos] != target[pos]) { return false; }\n }\n if(r[pos] != '\"') { return false; }\n return true;\n}\n\nsimdjson_inline bool raw_json_string::is_equal(std::string_view target) const noexcept {\n const char * r{raw()};\n size_t pos{0};\n bool escaping{false};\n for(;pos < target.size();pos++) {\n if(r[pos] != target[pos]) { return false; }\n // if target is a compile-time constant and it is free from\n // quotes, then the next part could get optimized away through\n // inlining.\n if((target[pos] == '\"') && !escaping) {\n // We have reached the end of the raw_json_string but\n // the target is not done.\n return false;\n } else if(target[pos] == '\\\\') {\n escaping = !escaping;\n } else {\n escaping = false;\n }\n }\n if(r[pos] != '\"') { return false; }\n return true;\n}\n\n\nsimdjson_inline bool raw_json_string::unsafe_is_equal(const char * target) const noexcept {\n // Assumptions: 'target' does not contain unescaped quote characters, is null terminated and\n // the raw content is quote terminated within a valid JSON string.\n const char * r{raw()};\n size_t pos{0};\n for(;target[pos];pos++) {\n if(r[pos] != target[pos]) { return false; }\n }\n if(r[pos] != '\"') { return false; }\n return true;\n}\n\nsimdjson_inline bool raw_json_string::is_equal(const char* target) const noexcept {\n // Assumptions: does not contain unescaped quote characters, and\n // the raw content is quote terminated within a valid JSON string.\n const char * r{raw()};\n size_t pos{0};\n bool escaping{false};\n for(;target[pos];pos++) {\n if(r[pos] != target[pos]) { return false; }\n // if target is a compile-time constant and it is free from\n // quotes, then the next part could get optimized away through\n // inlining.\n if((target[pos] == '\"') && !escaping) {\n // We have reached the end of the raw_json_string but\n // the target is not done.\n return false;\n } else if(target[pos] == '\\\\') {\n escaping = !escaping;\n } else {\n escaping = false;\n }\n }\n if(r[pos] != '\"') { return false; }\n return true;\n}\n\nsimdjson_unused simdjson_inline bool operator==(const raw_json_string &a, std::string_view c) noexcept {\n return a.unsafe_is_equal(c);\n}\n\nsimdjson_unused simdjson_inline bool operator==(std::string_view c, const raw_json_string &a) noexcept {\n return a == c;\n}\n\nsimdjson_unused simdjson_inline bool operator!=(const raw_json_string &a, std::string_view c) noexcept {\n return !(a == c);\n}\n\nsimdjson_unused simdjson_inline bool operator!=(std::string_view c, const raw_json_string &a) noexcept {\n return !(a == c);\n}\n\n\nsimdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape(json_iterator &iter, bool allow_replacement) const noexcept {\n return iter.unescape(*this, allow_replacement);\n}\n\nsimdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape_wobbly(json_iterator &iter) const noexcept {\n return iter.unescape_wobbly(*this);\n}\n\nsimdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &out, const raw_json_string &str) noexcept {\n bool in_escape = false;\n const char *s = str.raw();\n while (true) {\n switch (*s) {\n case '\\\\': in_escape = !in_escape; break;\n case '\"': if (in_escape) { in_escape = false; } else { return out; } break;\n default: if (in_escape) { in_escape = false; }\n }\n out << *s;\n s++;\n }\n}\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::raw_json_string>::simdjson_result(lasx::ondemand::raw_json_string &&value) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::raw_json_string>(std::forward<lasx::ondemand::raw_json_string>(value)) {}\nsimdjson_inline simdjson_result<lasx::ondemand::raw_json_string>::simdjson_result(error_code error) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::raw_json_string>(error) {}\n\nsimdjson_inline simdjson_result<const char *> simdjson_result<lasx::ondemand::raw_json_string>::raw() const noexcept {\n if (error()) { return error(); }\n return first.raw();\n}\nsimdjson_inline char simdjson_result<lasx::ondemand::raw_json_string>::operator[](size_t i) const noexcept {\n if (error()) { return error(); }\n return first[i];\n}\nsimdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<lasx::ondemand::raw_json_string>::unescape(lasx::ondemand::json_iterator &iter, bool allow_replacement) const noexcept {\n if (error()) { return error(); }\n return first.unescape(iter, allow_replacement);\n}\nsimdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<lasx::ondemand::raw_json_string>::unescape_wobbly(lasx::ondemand::json_iterator &iter) const noexcept {\n if (error()) { return error(); }\n return first.unescape_wobbly(iter);\n}\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_INL_H\n/* end file simdjson/generic/ondemand/raw_json_string-inl.h for lasx */\n/* including simdjson/generic/ondemand/serialization-inl.h for lasx: #include \"simdjson/generic/ondemand/serialization-inl.h\" */\n/* begin file simdjson/generic/ondemand/serialization-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/array.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/document-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_type.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/object.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/serialization.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value.h\" */\n/* amalgamation skipped (editor-only): #if SIMDJSON_STATIC_REFLECTION */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_builder.h\" */\n/* amalgamation skipped (editor-only): #endif */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\n\ninline std::string_view trim(const std::string_view str) noexcept {\n // We can almost surely do better by rolling our own find_first_not_of function.\n size_t first = str.find_first_not_of(\" \\t\\n\\r\");\n // If we have the empty string (just white space), then no trimming is possible, and\n // we return the empty string_view.\n if (std::string_view::npos == first) { return std::string_view(); }\n size_t last = str.find_last_not_of(\" \\t\\n\\r\");\n return str.substr(first, (last - first + 1));\n}\n\n\ninline simdjson_result<std::string_view> to_json_string(lasx::ondemand::document& x) noexcept {\n std::string_view v;\n auto error = x.raw_json().get(v);\n if(error) {return error; }\n return trim(v);\n}\n\ninline simdjson_result<std::string_view> to_json_string(lasx::ondemand::document_reference& x) noexcept {\n std::string_view v;\n auto error = x.raw_json().get(v);\n if(error) {return error; }\n return trim(v);\n}\n\ninline simdjson_result<std::string_view> to_json_string(lasx::ondemand::value& x) noexcept {\n /**\n * If we somehow receive a value that has already been consumed,\n * then the following code could be in trouble. E.g., we create\n * an array as needed, but if an array was already created, then\n * it could be bad.\n */\n using namespace lasx::ondemand;\n lasx::ondemand::json_type t;\n auto error = x.type().get(t);\n if(error != SUCCESS) { return error; }\n switch (t)\n {\n case json_type::array:\n {\n lasx::ondemand::array array;\n error = x.get_array().get(array);\n if(error) { return error; }\n return to_json_string(array);\n }\n case json_type::object:\n {\n lasx::ondemand::object object;\n error = x.get_object().get(object);\n if(error) { return error; }\n return to_json_string(object);\n }\n default:\n return trim(x.raw_json_token());\n }\n}\n\ninline simdjson_result<std::string_view> to_json_string(lasx::ondemand::object& x) noexcept {\n std::string_view v;\n auto error = x.raw_json().get(v);\n if(error) {return error; }\n return trim(v);\n}\n\ninline simdjson_result<std::string_view> to_json_string(lasx::ondemand::array& x) noexcept {\n std::string_view v;\n auto error = x.raw_json().get(v);\n if(error) {return error; }\n return trim(v);\n}\n\ninline simdjson_result<std::string_view> to_json_string(simdjson_result<lasx::ondemand::document> x) {\n if (x.error()) { return x.error(); }\n return to_json_string(x.value_unsafe());\n}\n\ninline simdjson_result<std::string_view> to_json_string(simdjson_result<lasx::ondemand::document_reference> x) {\n if (x.error()) { return x.error(); }\n return to_json_string(x.value_unsafe());\n}\n\ninline simdjson_result<std::string_view> to_json_string(simdjson_result<lasx::ondemand::value> x) {\n if (x.error()) { return x.error(); }\n return to_json_string(x.value_unsafe());\n}\n\ninline simdjson_result<std::string_view> to_json_string(simdjson_result<lasx::ondemand::object> x) {\n if (x.error()) { return x.error(); }\n return to_json_string(x.value_unsafe());\n}\n\ninline simdjson_result<std::string_view> to_json_string(simdjson_result<lasx::ondemand::array> x) {\n if (x.error()) { return x.error(); }\n return to_json_string(x.value_unsafe());\n}\n} // namespace simdjson\n\nnamespace simdjson { namespace lasx { namespace ondemand {\n\n#if SIMDJSON_EXCEPTIONS\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::value x) {\n std::string_view v;\n auto error = simdjson::to_json_string(x).get(v);\n if(error == simdjson::SUCCESS) {\n return (out << v);\n } else {\n throw simdjson::simdjson_error(error);\n }\n}\ninline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lasx::ondemand::value> x) {\n if (x.error()) { throw simdjson::simdjson_error(x.error()); }\n return (out << x.value());\n}\n#else\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::value x) {\n std::string_view v;\n auto error = simdjson::to_json_string(x).get(v);\n if(error == simdjson::SUCCESS) {\n return (out << v);\n } else {\n return (out << error);\n }\n}\n#endif\n\n#if SIMDJSON_EXCEPTIONS\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::array value) {\n std::string_view v;\n auto error = simdjson::to_json_string(value).get(v);\n if(error == simdjson::SUCCESS) {\n return (out << v);\n } else {\n throw simdjson::simdjson_error(error);\n }\n}\ninline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lasx::ondemand::array> x) {\n if (x.error()) { throw simdjson::simdjson_error(x.error()); }\n return (out << x.value());\n}\n#else\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::array value) {\n std::string_view v;\n auto error = simdjson::to_json_string(value).get(v);\n if(error == simdjson::SUCCESS) {\n return (out << v);\n } else {\n return (out << error);\n }\n}\n#endif\n\n#if SIMDJSON_EXCEPTIONS\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::document& value) {\n std::string_view v;\n auto error = simdjson::to_json_string(value).get(v);\n if(error == simdjson::SUCCESS) {\n return (out << v);\n } else {\n throw simdjson::simdjson_error(error);\n }\n}\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::document_reference& value) {\n std::string_view v;\n auto error = simdjson::to_json_string(value).get(v);\n if(error == simdjson::SUCCESS) {\n return (out << v);\n } else {\n throw simdjson::simdjson_error(error);\n }\n}\ninline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lasx::ondemand::document>&& x) {\n if (x.error()) { throw simdjson::simdjson_error(x.error()); }\n return (out << x.value());\n}\ninline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lasx::ondemand::document_reference>&& x) {\n if (x.error()) { throw simdjson::simdjson_error(x.error()); }\n return (out << x.value());\n}\n#else\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::document& value) {\n std::string_view v;\n auto error = simdjson::to_json_string(value).get(v);\n if(error == simdjson::SUCCESS) {\n return (out << v);\n } else {\n return (out << error);\n }\n}\n#endif\n\n#if SIMDJSON_EXCEPTIONS\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::object value) {\n std::string_view v;\n auto error = simdjson::to_json_string(value).get(v);\n if(error == simdjson::SUCCESS) {\n return (out << v);\n } else {\n throw simdjson::simdjson_error(error);\n }\n}\ninline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lasx::ondemand::object> x) {\n if (x.error()) { throw simdjson::simdjson_error(x.error()); }\n return (out << x.value());\n}\n#else\ninline std::ostream& operator<<(std::ostream& out, simdjson::lasx::ondemand::object value) {\n std::string_view v;\n auto error = simdjson::to_json_string(value).get(v);\n if(error == simdjson::SUCCESS) {\n return (out << v);\n } else {\n return (out << error);\n }\n}\n#endif\n}}} // namespace simdjson::lasx::ondemand\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H\n/* end file simdjson/generic/ondemand/serialization-inl.h for lasx */\n/* including simdjson/generic/ondemand/token_iterator-inl.h for lasx: #include \"simdjson/generic/ondemand/token_iterator-inl.h\" */\n/* begin file simdjson/generic/ondemand/token_iterator-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/token_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/implementation_simdjson_result_base-inl.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\nsimdjson_inline token_iterator::token_iterator(\n const uint8_t *_buf,\n token_position position\n) noexcept : buf{_buf}, _position{position}\n{\n}\n\nsimdjson_inline uint32_t token_iterator::current_offset() const noexcept {\n return *(_position);\n}\n\n\nsimdjson_inline const uint8_t *token_iterator::return_current_and_advance() noexcept {\n return &buf[*(_position++)];\n}\n\nsimdjson_inline const uint8_t *token_iterator::peek(token_position position) const noexcept {\n return &buf[*position];\n}\nsimdjson_inline uint32_t token_iterator::peek_index(token_position position) const noexcept {\n return *position;\n}\nsimdjson_inline uint32_t token_iterator::peek_length(token_position position) const noexcept {\n return *(position+1) - *position;\n}\n\nsimdjson_inline uint32_t token_iterator::peek_root_length(token_position position) const noexcept {\n return *(position+2) - *(position) > *(position+1) - *(position) ?\n *(position+1) - *(position)\n : *(position+2) - *(position);\n}\nsimdjson_inline const uint8_t *token_iterator::peek(int32_t delta) const noexcept {\n return &buf[*(_position+delta)];\n}\nsimdjson_inline uint32_t token_iterator::peek_index(int32_t delta) const noexcept {\n return *(_position+delta);\n}\nsimdjson_inline uint32_t token_iterator::peek_length(int32_t delta) const noexcept {\n return *(_position+delta+1) - *(_position+delta);\n}\n\nsimdjson_inline token_position token_iterator::position() const noexcept {\n return _position;\n}\nsimdjson_inline void token_iterator::set_position(token_position target_position) noexcept {\n _position = target_position;\n}\n\nsimdjson_inline bool token_iterator::operator==(const token_iterator &other) const noexcept {\n return _position == other._position;\n}\nsimdjson_inline bool token_iterator::operator!=(const token_iterator &other) const noexcept {\n return _position != other._position;\n}\nsimdjson_inline bool token_iterator::operator>(const token_iterator &other) const noexcept {\n return _position > other._position;\n}\nsimdjson_inline bool token_iterator::operator>=(const token_iterator &other) const noexcept {\n return _position >= other._position;\n}\nsimdjson_inline bool token_iterator::operator<(const token_iterator &other) const noexcept {\n return _position < other._position;\n}\nsimdjson_inline bool token_iterator::operator<=(const token_iterator &other) const noexcept {\n return _position <= other._position;\n}\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::token_iterator>::simdjson_result(lasx::ondemand::token_iterator &&value) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::token_iterator>(std::forward<lasx::ondemand::token_iterator>(value)) {}\nsimdjson_inline simdjson_result<lasx::ondemand::token_iterator>::simdjson_result(error_code error) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::token_iterator>(error) {}\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H\n/* end file simdjson/generic/ondemand/token_iterator-inl.h for lasx */\n/* including simdjson/generic/ondemand/value_iterator-inl.h for lasx: #include \"simdjson/generic/ondemand/value_iterator-inl.h\" */\n/* begin file simdjson/generic/ondemand/value_iterator-inl.h for lasx */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_VALUE_ITERATOR_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_VALUE_ITERATOR_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/base.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/atomparsing.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/numberparsing.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/value_iterator.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/json_type-inl.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/ondemand/raw_json_string-inl.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n\nsimdjson_inline value_iterator::value_iterator(\n json_iterator *json_iter,\n depth_t depth,\n token_position start_position\n) noexcept : _json_iter{json_iter}, _depth{depth}, _start_position{start_position}\n{\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::start_object() noexcept {\n SIMDJSON_TRY( start_container('{', \"Not an object\", \"object\") );\n return started_object();\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::start_root_object() noexcept {\n SIMDJSON_TRY( start_container('{', \"Not an object\", \"object\") );\n return started_root_object();\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::started_object() noexcept {\n assert_at_container_start();\n#if SIMDJSON_DEVELOPMENT_CHECKS\n _json_iter->set_start_position(_depth, start_position());\n#endif\n if (*_json_iter->peek() == '}') {\n logger::log_value(*_json_iter, \"empty object\");\n _json_iter->return_current_and_advance();\n SIMDJSON_TRY(end_container());\n return false;\n }\n return true;\n}\n\nsimdjson_warn_unused simdjson_inline error_code value_iterator::check_root_object() noexcept {\n // When in streaming mode, we cannot expect peek_last() to be the last structural element of the\n // current document. It only works in the normal mode where we have indexed a single document.\n // Note that adding a check for 'streaming' is not expensive since we only have at most\n // one root element.\n if ( ! _json_iter->streaming() ) {\n // The following lines do not fully protect against garbage content within the\n // object: e.g., `{\"a\":2} foo }`. Users concerned with garbage content should\n // call `at_end()` on the document instance at the end of the processing to\n // ensure that the processing has finished at the end.\n //\n if (*_json_iter->peek_last() != '}') {\n _json_iter->abandon();\n return report_error(INCOMPLETE_ARRAY_OR_OBJECT, \"missing } at end\");\n }\n // If the last character is } *and* the first gibberish character is also '}'\n // then on-demand could accidentally go over. So we need additional checks.\n // https://github.com/simdjson/simdjson/issues/1834\n // Checking that the document is balanced requires a full scan which is potentially\n // expensive, but it only happens in edge cases where the first padding character is\n // a closing bracket.\n if ((*_json_iter->peek(_json_iter->end_position()) == '}') && (!_json_iter->balanced())) {\n _json_iter->abandon();\n // The exact error would require more work. It will typically be an unclosed object.\n return report_error(INCOMPLETE_ARRAY_OR_OBJECT, \"the document is unbalanced\");\n }\n }\n return SUCCESS;\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::started_root_object() noexcept {\n auto error = check_root_object();\n if(error) { return error; }\n return started_object();\n}\n\nsimdjson_warn_unused simdjson_inline error_code value_iterator::end_container() noexcept {\n#if SIMDJSON_CHECK_EOF\n if (depth() > 1 && at_end()) { return report_error(INCOMPLETE_ARRAY_OR_OBJECT, \"missing parent ] or }\"); }\n // if (depth() <= 1 && !at_end()) { return report_error(INCOMPLETE_ARRAY_OR_OBJECT, \"missing [ or { at start\"); }\n#endif // SIMDJSON_CHECK_EOF\n _json_iter->ascend_to(depth()-1);\n return SUCCESS;\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::has_next_field() noexcept {\n assert_at_next();\n\n // It's illegal to call this unless there are more tokens: anything that ends in } or ] is\n // obligated to verify there are more tokens if they are not the top level.\n switch (*_json_iter->return_current_and_advance()) {\n case '}':\n logger::log_end_value(*_json_iter, \"object\");\n SIMDJSON_TRY( end_container() );\n return false;\n case ',':\n return true;\n default:\n return report_error(TAPE_ERROR, \"Missing comma between object fields\");\n }\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::find_field_raw(const std::string_view key) noexcept {\n error_code error;\n bool has_value;\n //\n // Initially, the object can be in one of a few different places:\n //\n // 1. The start of the object, at the first field:\n //\n // ```\n // { \"a\": [ 1, 2 ], \"b\": [ 3, 4 ] }\n // ^ (depth 2, index 1)\n // ```\n if (at_first_field()) {\n has_value = true;\n\n //\n // 2. When a previous search did not yield a value or the object is empty:\n //\n // ```\n // { \"a\": [ 1, 2 ], \"b\": [ 3, 4 ] }\n // ^ (depth 0)\n // { }\n // ^ (depth 0, index 2)\n // ```\n //\n } else if (!is_open()) {\n#if SIMDJSON_DEVELOPMENT_CHECKS\n // If we're past the end of the object, we're being iterated out of order.\n // Note: this is not perfect detection. It's possible the user is inside some other object; if so,\n // this object iterator will blithely scan that object for fields.\n if (_json_iter->depth() < depth() - 1) { return OUT_OF_ORDER_ITERATION; }\n#endif\n return false;\n\n // 3. When a previous search found a field or an iterator yielded a value:\n //\n // ```\n // // When a field was not fully consumed (or not even touched at all)\n // { \"a\": [ 1, 2 ], \"b\": [ 3, 4 ] }\n // ^ (depth 2)\n // // When a field was fully consumed\n // { \"a\": [ 1, 2 ], \"b\": [ 3, 4 ] }\n // ^ (depth 1)\n // // When the last field was fully consumed\n // { \"a\": [ 1, 2 ], \"b\": [ 3, 4 ] }\n // ^ (depth 1)\n // ```\n //\n } else {\n if ((error = skip_child() )) { abandon(); return error; }\n if ((error = has_next_field().get(has_value) )) { abandon(); return error; }\n#if SIMDJSON_DEVELOPMENT_CHECKS\n if (_json_iter->start_position(_depth) != start_position()) { return OUT_OF_ORDER_ITERATION; }\n#endif\n }\n while (has_value) {\n // Get the key and colon, stopping at the value.\n raw_json_string actual_key;\n // size_t max_key_length = _json_iter->peek_length() - 2; // -2 for the two quotes\n // Note: _json_iter->peek_length() - 2 might overflow if _json_iter->peek_length() < 2.\n // field_key() advances the pointer and checks that '\"' is found (corresponding to a key).\n // The depth is left unchanged by field_key().\n if ((error = field_key().get(actual_key) )) { abandon(); return error; };\n // field_value() will advance and check that we find a ':' separating the\n // key and the value. It will also increment the depth by one.\n if ((error = field_value() )) { abandon(); return error; }\n // If it matches, stop and return\n // We could do it this way if we wanted to allow arbitrary\n // key content (including escaped quotes).\n //if (actual_key.unsafe_is_equal(max_key_length, key)) {\n // Instead we do the following which may trigger buffer overruns if the\n // user provides an adversarial key (containing a well placed unescaped quote\n // character and being longer than the number of bytes remaining in the JSON\n // input).\n if (actual_key.unsafe_is_equal(key)) {\n logger::log_event(*this, \"match\", key, -2);\n // If we return here, then we return while pointing at the ':' that we just checked.\n return true;\n }\n\n // No match: skip the value and see if , or } is next\n logger::log_event(*this, \"no match\", key, -2);\n // The call to skip_child is meant to skip over the value corresponding to the key.\n // After skip_child(), we are right before the next comma (',') or the final brace ('}').\n SIMDJSON_TRY( skip_child() ); // Skip the value entirely\n // The has_next_field() advances the pointer and check that either ',' or '}' is found.\n // It returns true if ',' is found, false otherwise. If anything other than ',' or '}' is found,\n // then we are in error and we abort.\n if ((error = has_next_field().get(has_value) )) { abandon(); return error; }\n }\n\n // If the loop ended, we're out of fields to look at.\n return false;\n}\n\nSIMDJSON_PUSH_DISABLE_WARNINGS\nSIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::find_field_unordered_raw(const std::string_view key) noexcept {\n /**\n * When find_field_unordered_raw is called, we can either be pointing at the\n * first key, pointing outside (at the closing brace) or if a key was matched\n * we can be either pointing right afterthe ':' right before the value (that we need skip),\n * or we may have consumed the value and we might be at a comma or at the\n * final brace (ready for a call to has_next_field()).\n */\n error_code error;\n bool has_value;\n\n // First, we scan from that point to the end.\n // If we don't find a match, we may loop back around, and scan from the beginning to that point.\n token_position search_start = _json_iter->position();\n\n // We want to know whether we need to go back to the beginning.\n bool at_first = at_first_field();\n ///////////////\n // Initially, the object can be in one of a few different places:\n //\n // 1. At the first key:\n //\n // ```\n // { \"a\": [ 1, 2 ], \"b\": [ 3, 4 ] }\n // ^ (depth 2, index 1)\n // ```\n //\n if (at_first) {\n has_value = true;\n\n // 2. When a previous search did not yield a value or the object is empty:\n //\n // ```\n // { \"a\": [ 1, 2 ], \"b\": [ 3, 4 ] }\n // ^ (depth 0)\n // { }\n // ^ (depth 0, index 2)\n // ```\n //\n } else if (!is_open()) {\n\n#if SIMDJSON_DEVELOPMENT_CHECKS\n // If we're past the end of the object, we're being iterated out of order.\n // Note: this is not perfect detection. It's possible the user is inside some other object; if so,\n // this object iterator will blithely scan that object for fields.\n if (_json_iter->depth() < depth() - 1) { return OUT_OF_ORDER_ITERATION; }\n#endif\n SIMDJSON_TRY(reset_object().get(has_value));\n at_first = true;\n // 3. When a previous search found a field or an iterator yielded a value:\n //\n // ```\n // // When a field was not fully consumed (or not even touched at all)\n // { \"a\": [ 1, 2 ], \"b\": [ 3, 4 ] }\n // ^ (depth 2)\n // // When a field was fully consumed\n // { \"a\": [ 1, 2 ], \"b\": [ 3, 4 ] }\n // ^ (depth 1)\n // // When the last field was fully consumed\n // { \"a\": [ 1, 2 ], \"b\": [ 3, 4 ] }\n // ^ (depth 1)\n // ```\n //\n } else {\n // If someone queried a key but they not did access the value, then we are left pointing\n // at the ':' and we need to move forward through the value... If the value was\n // processed then skip_child() does not move the iterator (but may adjust the depth).\n if ((error = skip_child() )) { abandon(); return error; }\n search_start = _json_iter->position();\n if ((error = has_next_field().get(has_value) )) { abandon(); return error; }\n#if SIMDJSON_DEVELOPMENT_CHECKS\n if (_json_iter->start_position(_depth) != start_position()) { return OUT_OF_ORDER_ITERATION; }\n#endif\n }\n\n // After initial processing, we will be in one of two states:\n //\n // ```\n // // At the beginning of a field\n // { \"a\": [ 1, 2 ], \"b\": [ 3, 4 ] }\n // ^ (depth 1)\n // { \"a\": [ 1, 2 ], \"b\": [ 3, 4 ] }\n // ^ (depth 1)\n // // At the end of the object\n // { \"a\": [ 1, 2 ], \"b\": [ 3, 4 ] }\n // ^ (depth 0)\n // ```\n //\n // Next, we find a match starting from the current position.\n while (has_value) {\n SIMDJSON_ASSUME( _json_iter->_depth == _depth ); // We must be at the start of a field\n\n // Get the key and colon, stopping at the value.\n raw_json_string actual_key;\n // size_t max_key_length = _json_iter->peek_length() - 2; // -2 for the two quotes\n // Note: _json_iter->peek_length() - 2 might overflow if _json_iter->peek_length() < 2.\n // field_key() advances the pointer and checks that '\"' is found (corresponding to a key).\n // The depth is left unchanged by field_key().\n if ((error = field_key().get(actual_key) )) { abandon(); return error; };\n // field_value() will advance and check that we find a ':' separating the\n // key and the value. It will also increment the depth by one.\n if ((error = field_value() )) { abandon(); return error; }\n\n // If it matches, stop and return\n // We could do it this way if we wanted to allow arbitrary\n // key content (including escaped quotes).\n // if (actual_key.unsafe_is_equal(max_key_length, key)) {\n // Instead we do the following which may trigger buffer overruns if the\n // user provides an adversarial key (containing a well placed unescaped quote\n // character and being longer than the number of bytes remaining in the JSON\n // input).\n if (actual_key.unsafe_is_equal(key)) {\n logger::log_event(*this, \"match\", key, -2);\n // If we return here, then we return while pointing at the ':' that we just checked.\n return true;\n }\n\n // No match: skip the value and see if , or } is next\n logger::log_event(*this, \"no match\", key, -2);\n // The call to skip_child is meant to skip over the value corresponding to the key.\n // After skip_child(), we are right before the next comma (',') or the final brace ('}').\n SIMDJSON_TRY( skip_child() );\n // The has_next_field() advances the pointer and check that either ',' or '}' is found.\n // It returns true if ',' is found, false otherwise. If anything other than ',' or '}' is found,\n // then we are in error and we abort.\n if ((error = has_next_field().get(has_value) )) { abandon(); return error; }\n }\n // Performance note: it maybe wasteful to rewind to the beginning when there might be\n // no other query following. Indeed, it would require reskipping the whole object.\n // Instead, you can just stay where you are. If there is a new query, there is always time\n // to rewind.\n if(at_first) { return false; }\n\n // If we reach the end without finding a match, search the rest of the fields starting at the\n // beginning of the object.\n // (We have already run through the object before, so we've already validated its structure. We\n // don't check errors in this bit.)\n SIMDJSON_TRY(reset_object().get(has_value));\n while (true) {\n SIMDJSON_ASSUME(has_value); // we should reach search_start before ever reaching the end of the object\n SIMDJSON_ASSUME( _json_iter->_depth == _depth ); // We must be at the start of a field\n\n // Get the key and colon, stopping at the value.\n raw_json_string actual_key;\n // size_t max_key_length = _json_iter->peek_length() - 2; // -2 for the two quotes\n // Note: _json_iter->peek_length() - 2 might overflow if _json_iter->peek_length() < 2.\n // field_key() advances the pointer and checks that '\"' is found (corresponding to a key).\n // The depth is left unchanged by field_key().\n error = field_key().get(actual_key); SIMDJSON_ASSUME(!error);\n // field_value() will advance and check that we find a ':' separating the\n // key and the value. It will also increment the depth by one.\n error = field_value(); SIMDJSON_ASSUME(!error);\n\n // If it matches, stop and return\n // We could do it this way if we wanted to allow arbitrary\n // key content (including escaped quotes).\n // if (actual_key.unsafe_is_equal(max_key_length, key)) {\n // Instead we do the following which may trigger buffer overruns if the\n // user provides an adversarial key (containing a well placed unescaped quote\n // character and being longer than the number of bytes remaining in the JSON\n // input).\n if (actual_key.unsafe_is_equal(key)) {\n logger::log_event(*this, \"match\", key, -2);\n // If we return here, then we return while pointing at the ':' that we just checked.\n return true;\n }\n\n // No match: skip the value and see if , or } is next\n logger::log_event(*this, \"no match\", key, -2);\n // The call to skip_child is meant to skip over the value corresponding to the key.\n // After skip_child(), we are right before the next comma (',') or the final brace ('}').\n SIMDJSON_TRY( skip_child() );\n // If we reached the end of the key-value pair we started from, then we know\n // that the key is not there so we return false. We are either right before\n // the next comma or the final brace.\n if(_json_iter->position() == search_start) { return false; }\n // The has_next_field() advances the pointer and check that either ',' or '}' is found.\n // It returns true if ',' is found, false otherwise. If anything other than ',' or '}' is found,\n // then we are in error and we abort.\n error = has_next_field().get(has_value); SIMDJSON_ASSUME(!error);\n // If we make the mistake of exiting here, then we could be left pointing at a key\n // in the middle of an object. That's not an allowable state.\n }\n // If the loop ended, we're out of fields to look at. The program should\n // never reach this point.\n return false;\n}\nSIMDJSON_POP_DISABLE_WARNINGS\n\nsimdjson_warn_unused simdjson_inline simdjson_result<raw_json_string> value_iterator::field_key() noexcept {\n assert_at_next();\n\n const uint8_t *key = _json_iter->return_current_and_advance();\n if (*(key++) != '\"') { return report_error(TAPE_ERROR, \"Object key is not a string\"); }\n return raw_json_string(key);\n}\n\nsimdjson_warn_unused simdjson_inline error_code value_iterator::field_value() noexcept {\n assert_at_next();\n\n if (*_json_iter->return_current_and_advance() != ':') { return report_error(TAPE_ERROR, \"Missing colon in object field\"); }\n _json_iter->descend_to(depth()+1);\n return SUCCESS;\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::start_array() noexcept {\n SIMDJSON_TRY( start_container('[', \"Not an array\", \"array\") );\n return started_array();\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::start_root_array() noexcept {\n SIMDJSON_TRY( start_container('[', \"Not an array\", \"array\") );\n return started_root_array();\n}\n\ninline std::string value_iterator::to_string() const noexcept {\n auto answer = std::string(\"value_iterator [ depth : \") + std::to_string(_depth) + std::string(\", \");\n if(_json_iter != nullptr) { answer += _json_iter->to_string(); }\n answer += std::string(\" ]\");\n return answer;\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::started_array() noexcept {\n assert_at_container_start();\n if (*_json_iter->peek() == ']') {\n logger::log_value(*_json_iter, \"empty array\");\n _json_iter->return_current_and_advance();\n SIMDJSON_TRY( end_container() );\n return false;\n }\n _json_iter->descend_to(depth()+1);\n#if SIMDJSON_DEVELOPMENT_CHECKS\n _json_iter->set_start_position(_depth, start_position());\n#endif\n return true;\n}\n\nsimdjson_warn_unused simdjson_inline error_code value_iterator::check_root_array() noexcept {\n // When in streaming mode, we cannot expect peek_last() to be the last structural element of the\n // current document. It only works in the normal mode where we have indexed a single document.\n // Note that adding a check for 'streaming' is not expensive since we only have at most\n // one root element.\n if ( ! _json_iter->streaming() ) {\n // The following lines do not fully protect against garbage content within the\n // array: e.g., `[1, 2] foo]`. Users concerned with garbage content should\n // also call `at_end()` on the document instance at the end of the processing to\n // ensure that the processing has finished at the end.\n //\n if (*_json_iter->peek_last() != ']') {\n _json_iter->abandon();\n return report_error(INCOMPLETE_ARRAY_OR_OBJECT, \"missing ] at end\");\n }\n // If the last character is ] *and* the first gibberish character is also ']'\n // then on-demand could accidentally go over. So we need additional checks.\n // https://github.com/simdjson/simdjson/issues/1834\n // Checking that the document is balanced requires a full scan which is potentially\n // expensive, but it only happens in edge cases where the first padding character is\n // a closing bracket.\n if ((*_json_iter->peek(_json_iter->end_position()) == ']') && (!_json_iter->balanced())) {\n _json_iter->abandon();\n // The exact error would require more work. It will typically be an unclosed array.\n return report_error(INCOMPLETE_ARRAY_OR_OBJECT, \"the document is unbalanced\");\n }\n }\n return SUCCESS;\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::started_root_array() noexcept {\n auto error = check_root_array();\n if (error) { return error; }\n return started_array();\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::has_next_element() noexcept {\n assert_at_next();\n\n logger::log_event(*this, \"has_next_element\");\n switch (*_json_iter->return_current_and_advance()) {\n case ']':\n logger::log_end_value(*_json_iter, \"array\");\n SIMDJSON_TRY( end_container() );\n return false;\n case ',':\n _json_iter->descend_to(depth()+1);\n return true;\n default:\n return report_error(TAPE_ERROR, \"Missing comma between array elements\");\n }\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::parse_bool(const uint8_t *json) const noexcept {\n auto not_true = atomparsing::str4ncmp(json, \"true\");\n auto not_false = atomparsing::str4ncmp(json, \"fals\") | (json[4] ^ 'e');\n bool error = (not_true && not_false) || jsoncharutils::is_not_structural_or_whitespace(json[not_true ? 5 : 4]);\n if (error) { return incorrect_type_error(\"Not a boolean\"); }\n return simdjson_result<bool>(!not_true);\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::parse_null(const uint8_t *json) const noexcept {\n bool is_null_string = !atomparsing::str4ncmp(json, \"null\") && jsoncharutils::is_structural_or_whitespace(json[4]);\n // if we start with 'n', we must be a null\n if(!is_null_string && json[0]=='n') { return incorrect_type_error(\"Not a null but starts with n\"); }\n return is_null_string;\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<std::string_view> value_iterator::get_string(bool allow_replacement) noexcept {\n return get_raw_json_string().unescape(json_iter(), allow_replacement);\n}\ntemplate <typename string_type>\nsimdjson_warn_unused simdjson_inline error_code value_iterator::get_string(string_type& receiver, bool allow_replacement) noexcept {\n std::string_view content;\n auto err = get_string(allow_replacement).get(content);\n if (err) { return err; }\n receiver = content;\n return SUCCESS;\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<std::string_view> value_iterator::get_wobbly_string() noexcept {\n return get_raw_json_string().unescape_wobbly(json_iter());\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<raw_json_string> value_iterator::get_raw_json_string() noexcept {\n auto json = peek_scalar(\"string\");\n if (*json != '\"') { return incorrect_type_error(\"Not a string\"); }\n advance_scalar(\"string\");\n return raw_json_string(json+1);\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<uint64_t> value_iterator::get_uint64() noexcept {\n auto result = numberparsing::parse_unsigned(peek_non_root_scalar(\"uint64\"));\n if(result.error() == SUCCESS) { advance_non_root_scalar(\"uint64\"); }\n return result;\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<uint64_t> value_iterator::get_uint64_in_string() noexcept {\n auto result = numberparsing::parse_unsigned_in_string(peek_non_root_scalar(\"uint64\"));\n if(result.error() == SUCCESS) { advance_non_root_scalar(\"uint64\"); }\n return result;\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<int64_t> value_iterator::get_int64() noexcept {\n auto result = numberparsing::parse_integer(peek_non_root_scalar(\"int64\"));\n if(result.error() == SUCCESS) { advance_non_root_scalar(\"int64\"); }\n return result;\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<int64_t> value_iterator::get_int64_in_string() noexcept {\n auto result = numberparsing::parse_integer_in_string(peek_non_root_scalar(\"int64\"));\n if(result.error() == SUCCESS) { advance_non_root_scalar(\"int64\"); }\n return result;\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<double> value_iterator::get_double() noexcept {\n auto result = numberparsing::parse_double(peek_non_root_scalar(\"double\"));\n if(result.error() == SUCCESS) { advance_non_root_scalar(\"double\"); }\n return result;\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<double> value_iterator::get_double_in_string() noexcept {\n auto result = numberparsing::parse_double_in_string(peek_non_root_scalar(\"double\"));\n if(result.error() == SUCCESS) { advance_non_root_scalar(\"double\"); }\n return result;\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::get_bool() noexcept {\n auto result = parse_bool(peek_non_root_scalar(\"bool\"));\n if(result.error() == SUCCESS) { advance_non_root_scalar(\"bool\"); }\n return result;\n}\nsimdjson_inline simdjson_result<bool> value_iterator::is_null() noexcept {\n bool is_null_value;\n SIMDJSON_TRY(parse_null(peek_non_root_scalar(\"null\")).get(is_null_value));\n if(is_null_value) { advance_non_root_scalar(\"null\"); }\n return is_null_value;\n}\nsimdjson_inline bool value_iterator::is_negative() noexcept {\n return numberparsing::is_negative(peek_non_root_scalar(\"numbersign\"));\n}\nsimdjson_inline bool value_iterator::is_root_negative() noexcept {\n return numberparsing::is_negative(peek_root_scalar(\"numbersign\"));\n}\nsimdjson_inline simdjson_result<bool> value_iterator::is_integer() noexcept {\n return numberparsing::is_integer(peek_non_root_scalar(\"integer\"));\n}\nsimdjson_inline simdjson_result<number_type> value_iterator::get_number_type() noexcept {\n return numberparsing::get_number_type(peek_non_root_scalar(\"integer\"));\n}\nsimdjson_inline simdjson_result<number> value_iterator::get_number() noexcept {\n number num;\n error_code error = numberparsing::parse_number(peek_non_root_scalar(\"number\"), num);\n if(error) { return error; }\n return num;\n}\n\nsimdjson_inline simdjson_result<bool> value_iterator::is_root_integer(bool check_trailing) noexcept {\n auto max_len = peek_root_length();\n auto json = peek_root_scalar(\"is_root_integer\");\n uint8_t tmpbuf[20+1+1]{}; // <20 digits> is the longest possible unsigned integer\n tmpbuf[20+1] = '\\0'; // make sure that buffer is always null terminated.\n if (!_json_iter->copy_to_buffer(json, max_len, tmpbuf, 20+1)) {\n return false; // if there are more than 20 characters, it cannot be represented as an integer.\n }\n auto answer = numberparsing::is_integer(tmpbuf);\n // If the parsing was a success, we must still check that it is\n // a single scalar. Note that we parse first because of cases like '[]' where\n // getting TRAILING_CONTENT is wrong.\n if(check_trailing && (answer.error() == SUCCESS) && (!_json_iter->is_single_token())) { return TRAILING_CONTENT; }\n return answer;\n}\n\nsimdjson_inline simdjson_result<lasx::number_type> value_iterator::get_root_number_type(bool check_trailing) noexcept {\n auto max_len = peek_root_length();\n auto json = peek_root_scalar(\"number\");\n // Per https://www.exploringbinary.com/maximum-number-of-decimal-digits-in-binary-floating-point-numbers/,\n // 1074 is the maximum number of significant fractional digits. Add 8 more digits for the biggest\n // number: -0.<fraction>e-308.\n uint8_t tmpbuf[1074+8+1+1];\n tmpbuf[1074+8+1] = '\\0'; // make sure that buffer is always null terminated.\n if (!_json_iter->copy_to_buffer(json, max_len, tmpbuf, 1074+8+1)) {\n if(numberparsing::check_if_integer(json, max_len)) {\n if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }\n logger::log_error(*_json_iter, start_position(), depth(), \"Found big integer\");\n return number_type::big_integer;\n }\n logger::log_error(*_json_iter, start_position(), depth(), \"Root number more than 1082 characters and not a big integer\");\n return NUMBER_ERROR;\n }\n auto answer = numberparsing::get_number_type(tmpbuf);\n if (check_trailing && (answer.error() == SUCCESS) && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }\n return answer;\n}\nsimdjson_inline simdjson_result<number> value_iterator::get_root_number(bool check_trailing) noexcept {\n auto max_len = peek_root_length();\n auto json = peek_root_scalar(\"number\");\n // Per https://www.exploringbinary.com/maximum-number-of-decimal-digits-in-binary-floating-point-numbers/,\n // 1074 is the maximum number of significant fractional digits. Add 8 more digits for the biggest\n // number: -0.<fraction>e-308.\n // NOTE: the current approach doesn't work for very big integer numbers containing more than 1074 digits.\n uint8_t tmpbuf[1074+8+1+1];\n tmpbuf[1074+8+1] = '\\0'; // make sure that buffer is always null terminated.\n if (!_json_iter->copy_to_buffer(json, max_len, tmpbuf, 1074+8+1)) {\n if(numberparsing::check_if_integer(json, max_len)) {\n if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }\n logger::log_error(*_json_iter, start_position(), depth(), \"Found big integer\");\n return BIGINT_ERROR;\n }\n logger::log_error(*_json_iter, start_position(), depth(), \"Root number more than 1082 characters and not a big integer\");\n return NUMBER_ERROR;\n }\n number num;\n error_code error = numberparsing::parse_number(tmpbuf, num);\n if(error) { return error; }\n if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }\n advance_root_scalar(\"number\");\n return num;\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<std::string_view> value_iterator::get_root_string(bool check_trailing, bool allow_replacement) noexcept {\n return get_root_raw_json_string(check_trailing).unescape(json_iter(), allow_replacement);\n}\ntemplate <typename string_type>\nsimdjson_warn_unused simdjson_inline error_code value_iterator::get_root_string(string_type& receiver, bool check_trailing, bool allow_replacement) noexcept {\n std::string_view content;\n auto err = get_root_string(check_trailing, allow_replacement).get(content);\n if (err) { return err; }\n receiver = content;\n return SUCCESS;\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<std::string_view> value_iterator::get_root_wobbly_string(bool check_trailing) noexcept {\n return get_root_raw_json_string(check_trailing).unescape_wobbly(json_iter());\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<raw_json_string> value_iterator::get_root_raw_json_string(bool check_trailing) noexcept {\n auto json = peek_scalar(\"string\");\n if (*json != '\"') { return incorrect_type_error(\"Not a string\"); }\n if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }\n advance_scalar(\"string\");\n return raw_json_string(json+1);\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<uint64_t> value_iterator::get_root_uint64(bool check_trailing) noexcept {\n auto max_len = peek_root_length();\n auto json = peek_root_scalar(\"uint64\");\n uint8_t tmpbuf[20+1+1]{}; // <20 digits> is the longest possible unsigned integer\n tmpbuf[20+1] = '\\0'; // make sure that buffer is always null terminated.\n if (!_json_iter->copy_to_buffer(json, max_len, tmpbuf, 20+1)) {\n logger::log_error(*_json_iter, start_position(), depth(), \"Root number more than 20 characters\");\n return NUMBER_ERROR;\n }\n auto result = numberparsing::parse_unsigned(tmpbuf);\n if(result.error() == SUCCESS) {\n if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }\n advance_root_scalar(\"uint64\");\n }\n return result;\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<uint64_t> value_iterator::get_root_uint64_in_string(bool check_trailing) noexcept {\n auto max_len = peek_root_length();\n auto json = peek_root_scalar(\"uint64\");\n uint8_t tmpbuf[20+1+1]{}; // <20 digits> is the longest possible unsigned integer\n tmpbuf[20+1] = '\\0'; // make sure that buffer is always null terminated.\n if (!_json_iter->copy_to_buffer(json, max_len, tmpbuf, 20+1)) {\n logger::log_error(*_json_iter, start_position(), depth(), \"Root number more than 20 characters\");\n return NUMBER_ERROR;\n }\n auto result = numberparsing::parse_unsigned_in_string(tmpbuf);\n if(result.error() == SUCCESS) {\n if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }\n advance_root_scalar(\"uint64\");\n }\n return result;\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<int64_t> value_iterator::get_root_int64(bool check_trailing) noexcept {\n auto max_len = peek_root_length();\n auto json = peek_root_scalar(\"int64\");\n uint8_t tmpbuf[20+1+1]; // -<19 digits> is the longest possible integer\n tmpbuf[20+1] = '\\0'; // make sure that buffer is always null terminated.\n if (!_json_iter->copy_to_buffer(json, max_len, tmpbuf, 20+1)) {\n logger::log_error(*_json_iter, start_position(), depth(), \"Root number more than 20 characters\");\n return NUMBER_ERROR;\n }\n\n auto result = numberparsing::parse_integer(tmpbuf);\n if(result.error() == SUCCESS) {\n if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }\n advance_root_scalar(\"int64\");\n }\n return result;\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<int64_t> value_iterator::get_root_int64_in_string(bool check_trailing) noexcept {\n auto max_len = peek_root_length();\n auto json = peek_root_scalar(\"int64\");\n uint8_t tmpbuf[20+1+1]; // -<19 digits> is the longest possible integer\n tmpbuf[20+1] = '\\0'; // make sure that buffer is always null terminated.\n if (!_json_iter->copy_to_buffer(json, max_len, tmpbuf, 20+1)) {\n logger::log_error(*_json_iter, start_position(), depth(), \"Root number more than 20 characters\");\n return NUMBER_ERROR;\n }\n\n auto result = numberparsing::parse_integer_in_string(tmpbuf);\n if(result.error() == SUCCESS) {\n if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }\n advance_root_scalar(\"int64\");\n }\n return result;\n}\nsimdjson_warn_unused simdjson_inline simdjson_result<double> value_iterator::get_root_double(bool check_trailing) noexcept {\n auto max_len = peek_root_length();\n auto json = peek_root_scalar(\"double\");\n // Per https://www.exploringbinary.com/maximum-number-of-decimal-digits-in-binary-floating-point-numbers/,\n // 1074 is the maximum number of significant fractional digits. Add 8 more digits for the biggest\n // number: -0.<fraction>e-308.\n uint8_t tmpbuf[1074+8+1+1]; // +1 for null termination.\n tmpbuf[1074+8+1] = '\\0'; // make sure that buffer is always null terminated.\n if (!_json_iter->copy_to_buffer(json, max_len, tmpbuf, 1074+8+1)) {\n logger::log_error(*_json_iter, start_position(), depth(), \"Root number more than 1082 characters\");\n return NUMBER_ERROR;\n }\n auto result = numberparsing::parse_double(tmpbuf);\n if(result.error() == SUCCESS) {\n if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }\n advance_root_scalar(\"double\");\n }\n return result;\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<double> value_iterator::get_root_double_in_string(bool check_trailing) noexcept {\n auto max_len = peek_root_length();\n auto json = peek_root_scalar(\"double\");\n // Per https://www.exploringbinary.com/maximum-number-of-decimal-digits-in-binary-floating-point-numbers/,\n // 1074 is the maximum number of significant fractional digits. Add 8 more digits for the biggest\n // number: -0.<fraction>e-308.\n uint8_t tmpbuf[1074+8+1+1]; // +1 for null termination.\n tmpbuf[1074+8+1] = '\\0'; // make sure that buffer is always null terminated.\n if (!_json_iter->copy_to_buffer(json, max_len, tmpbuf, 1074+8+1)) {\n logger::log_error(*_json_iter, start_position(), depth(), \"Root number more than 1082 characters\");\n return NUMBER_ERROR;\n }\n auto result = numberparsing::parse_double_in_string(tmpbuf);\n if(result.error() == SUCCESS) {\n if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }\n advance_root_scalar(\"double\");\n }\n return result;\n}\n\nsimdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::get_root_bool(bool check_trailing) noexcept {\n auto max_len = peek_root_length();\n auto json = peek_root_scalar(\"bool\");\n // We have a boolean if we have either \"true\" or \"false\" and the next character is either\n // a structural character or whitespace. We also check that the length is correct:\n // \"true\" and \"false\" are 4 and 5 characters long, respectively.\n bool value_true = (max_len >= 4 && !atomparsing::str4ncmp(json, \"true\") &&\n (max_len == 4 || jsoncharutils::is_structural_or_whitespace(json[4])));\n bool value_false = (max_len >= 5 && !atomparsing::str4ncmp(json, \"false\") &&\n (max_len == 5 || jsoncharutils::is_structural_or_whitespace(json[5])));\n if(value_true == false && value_false == false) { return incorrect_type_error(\"Not a boolean\"); }\n if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }\n advance_root_scalar(\"bool\");\n return value_true;\n}\n\nsimdjson_inline simdjson_result<bool> value_iterator::is_root_null(bool check_trailing) noexcept {\n auto max_len = peek_root_length();\n auto json = peek_root_scalar(\"null\");\n bool result = (max_len >= 4 && !atomparsing::str4ncmp(json, \"null\") &&\n (max_len == 4 || jsoncharutils::is_structural_or_whitespace(json[4])));\n if(result) { // we have something that looks like a null.\n if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }\n advance_root_scalar(\"null\");\n } else if (json[0] == 'n') {\n return incorrect_type_error(\"Not a null but starts with n\");\n }\n return result;\n}\n\nsimdjson_warn_unused simdjson_inline error_code value_iterator::skip_child() noexcept {\n SIMDJSON_ASSUME( _json_iter->token._position > _start_position );\n SIMDJSON_ASSUME( _json_iter->_depth >= _depth );\n\n return _json_iter->skip_child(depth());\n}\n\nsimdjson_inline value_iterator value_iterator::child() const noexcept {\n assert_at_child();\n return { _json_iter, depth()+1, _json_iter->token.position() };\n}\n\n// GCC 7 warns when the first line of this function is inlined away into oblivion due to the caller\n// relating depth and iterator depth, which is a desired effect. It does not happen if is_open is\n// marked non-inline.\nSIMDJSON_PUSH_DISABLE_WARNINGS\nSIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING\nsimdjson_inline bool value_iterator::is_open() const noexcept {\n return _json_iter->depth() >= depth();\n}\nSIMDJSON_POP_DISABLE_WARNINGS\n\nsimdjson_inline bool value_iterator::at_end() const noexcept {\n return _json_iter->at_end();\n}\n\nsimdjson_inline bool value_iterator::at_start() const noexcept {\n return _json_iter->token.position() == start_position();\n}\n\nsimdjson_inline bool value_iterator::at_first_field() const noexcept {\n SIMDJSON_ASSUME( _json_iter->token._position > _start_position );\n return _json_iter->token.position() == start_position() + 1;\n}\n\nsimdjson_inline void value_iterator::abandon() noexcept {\n _json_iter->abandon();\n}\n\nsimdjson_warn_unused simdjson_inline depth_t value_iterator::depth() const noexcept {\n return _depth;\n}\nsimdjson_warn_unused simdjson_inline error_code value_iterator::error() const noexcept {\n return _json_iter->error;\n}\nsimdjson_warn_unused simdjson_inline uint8_t *&value_iterator::string_buf_loc() noexcept {\n return _json_iter->string_buf_loc();\n}\nsimdjson_warn_unused simdjson_inline const json_iterator &value_iterator::json_iter() const noexcept {\n return *_json_iter;\n}\nsimdjson_warn_unused simdjson_inline json_iterator &value_iterator::json_iter() noexcept {\n return *_json_iter;\n}\n\nsimdjson_inline const uint8_t *value_iterator::peek_start() const noexcept {\n return _json_iter->peek(start_position());\n}\nsimdjson_inline uint32_t value_iterator::peek_start_length() const noexcept {\n return _json_iter->peek_length(start_position());\n}\nsimdjson_inline uint32_t value_iterator::peek_root_length() const noexcept {\n return _json_iter->peek_root_length(start_position());\n}\n\nsimdjson_inline const uint8_t *value_iterator::peek_scalar(const char *type) noexcept {\n logger::log_value(*_json_iter, start_position(), depth(), type);\n // If we're not at the position anymore, we don't want to advance the cursor.\n if (!is_at_start()) { return peek_start(); }\n\n // Get the JSON and advance the cursor, decreasing depth to signify that we have retrieved the value.\n assert_at_start();\n return _json_iter->peek();\n}\n\nsimdjson_inline void value_iterator::advance_scalar(const char *type) noexcept {\n logger::log_value(*_json_iter, start_position(), depth(), type);\n // If we're not at the position anymore, we don't want to advance the cursor.\n if (!is_at_start()) { return; }\n\n // Get the JSON and advance the cursor, decreasing depth to signify that we have retrieved the value.\n assert_at_start();\n _json_iter->return_current_and_advance();\n _json_iter->ascend_to(depth()-1);\n}\n\nsimdjson_warn_unused simdjson_inline error_code value_iterator::start_container(uint8_t start_char, const char *incorrect_type_message, const char *type) noexcept {\n logger::log_start_value(*_json_iter, start_position(), depth(), type);\n // If we're not at the position anymore, we don't want to advance the cursor.\n const uint8_t *json;\n if (!is_at_start()) {\n#if SIMDJSON_DEVELOPMENT_CHECKS\n if (!is_at_iterator_start()) { return OUT_OF_ORDER_ITERATION; }\n#endif\n json = peek_start();\n if (*json != start_char) { return incorrect_type_error(incorrect_type_message); }\n } else {\n assert_at_start();\n /**\n * We should be prudent. Let us peek. If it is not the right type, we\n * return an error. Only once we have determined that we have the right\n * type are we allowed to advance!\n */\n json = _json_iter->peek();\n if (*json != start_char) { return incorrect_type_error(incorrect_type_message); }\n _json_iter->return_current_and_advance();\n }\n\n\n return SUCCESS;\n}\n\n\nsimdjson_inline const uint8_t *value_iterator::peek_root_scalar(const char *type) noexcept {\n logger::log_value(*_json_iter, start_position(), depth(), type);\n if (!is_at_start()) { return peek_start(); }\n\n assert_at_root();\n return _json_iter->peek();\n}\nsimdjson_inline const uint8_t *value_iterator::peek_non_root_scalar(const char *type) noexcept {\n logger::log_value(*_json_iter, start_position(), depth(), type);\n if (!is_at_start()) { return peek_start(); }\n\n assert_at_non_root_start();\n return _json_iter->peek();\n}\n\nsimdjson_inline void value_iterator::advance_root_scalar(const char *type) noexcept {\n logger::log_value(*_json_iter, start_position(), depth(), type);\n if (!is_at_start()) { return; }\n\n assert_at_root();\n _json_iter->return_current_and_advance();\n _json_iter->ascend_to(depth()-1);\n}\nsimdjson_inline void value_iterator::advance_non_root_scalar(const char *type) noexcept {\n logger::log_value(*_json_iter, start_position(), depth(), type);\n if (!is_at_start()) { return; }\n\n assert_at_non_root_start();\n _json_iter->return_current_and_advance();\n _json_iter->ascend_to(depth()-1);\n}\n\nsimdjson_inline error_code value_iterator::incorrect_type_error(const char *message) const noexcept {\n logger::log_error(*_json_iter, start_position(), depth(), message);\n return INCORRECT_TYPE;\n}\n\nsimdjson_inline bool value_iterator::is_at_start() const noexcept {\n return position() == start_position();\n}\n\nsimdjson_inline bool value_iterator::is_at_key() const noexcept {\n // Keys are at the same depth as the object.\n // Note here that we could be safer and check that we are within an object,\n // but we do not.\n return _depth == _json_iter->_depth && *_json_iter->peek() == '\"';\n}\n\nsimdjson_inline bool value_iterator::is_at_iterator_start() const noexcept {\n // We can legitimately be either at the first value ([1]), or after the array if it's empty ([]).\n auto delta = position() - start_position();\n return delta == 1 || delta == 2;\n}\n\ninline void value_iterator::assert_at_start() const noexcept {\n SIMDJSON_ASSUME( _json_iter->token._position == _start_position );\n SIMDJSON_ASSUME( _json_iter->_depth == _depth );\n SIMDJSON_ASSUME( _depth > 0 );\n}\n\ninline void value_iterator::assert_at_container_start() const noexcept {\n SIMDJSON_ASSUME( _json_iter->token._position == _start_position + 1 );\n SIMDJSON_ASSUME( _json_iter->_depth == _depth );\n SIMDJSON_ASSUME( _depth > 0 );\n}\n\ninline void value_iterator::assert_at_next() const noexcept {\n SIMDJSON_ASSUME( _json_iter->token._position > _start_position );\n SIMDJSON_ASSUME( _json_iter->_depth == _depth );\n SIMDJSON_ASSUME( _depth > 0 );\n}\n\nsimdjson_inline void value_iterator::move_at_start() noexcept {\n _json_iter->_depth = _depth;\n _json_iter->token.set_position(_start_position);\n}\n\nsimdjson_inline void value_iterator::move_at_container_start() noexcept {\n _json_iter->_depth = _depth;\n _json_iter->token.set_position(_start_position + 1);\n}\n\nsimdjson_inline simdjson_result<bool> value_iterator::reset_array() noexcept {\n if(error()) { return error(); }\n move_at_container_start();\n return started_array();\n}\n\nsimdjson_inline simdjson_result<bool> value_iterator::reset_object() noexcept {\n if(error()) { return error(); }\n move_at_container_start();\n return started_object();\n}\n\ninline void value_iterator::assert_at_child() const noexcept {\n SIMDJSON_ASSUME( _json_iter->token._position > _start_position );\n SIMDJSON_ASSUME( _json_iter->_depth == _depth + 1 );\n SIMDJSON_ASSUME( _depth > 0 );\n}\n\ninline void value_iterator::assert_at_root() const noexcept {\n assert_at_start();\n SIMDJSON_ASSUME( _depth == 1 );\n}\n\ninline void value_iterator::assert_at_non_root_start() const noexcept {\n assert_at_start();\n SIMDJSON_ASSUME( _depth > 1 );\n}\n\ninline void value_iterator::assert_is_valid() const noexcept {\n SIMDJSON_ASSUME( _json_iter != nullptr );\n}\n\nsimdjson_inline bool value_iterator::is_valid() const noexcept {\n return _json_iter != nullptr;\n}\n\nsimdjson_inline simdjson_result<json_type> value_iterator::type() const noexcept {\n switch (*peek_start()) {\n case '{':\n return json_type::object;\n case '[':\n return json_type::array;\n case '\"':\n return json_type::string;\n case 'n':\n return json_type::null;\n case 't': case 'f':\n return json_type::boolean;\n case '-':\n case '0': case '1': case '2': case '3': case '4':\n case '5': case '6': case '7': case '8': case '9':\n return json_type::number;\n default:\n return json_type::unknown;\n }\n}\n\nsimdjson_inline token_position value_iterator::start_position() const noexcept {\n return _start_position;\n}\n\nsimdjson_inline token_position value_iterator::position() const noexcept {\n return _json_iter->position();\n}\n\nsimdjson_inline token_position value_iterator::end_position() const noexcept {\n return _json_iter->end_position();\n}\n\nsimdjson_inline token_position value_iterator::last_position() const noexcept {\n return _json_iter->last_position();\n}\n\nsimdjson_inline error_code value_iterator::report_error(error_code error, const char *message) noexcept {\n return _json_iter->report_error(error, message);\n}\n\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\nnamespace simdjson {\n\nsimdjson_inline simdjson_result<lasx::ondemand::value_iterator>::simdjson_result(lasx::ondemand::value_iterator &&value) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::value_iterator>(std::forward<lasx::ondemand::value_iterator>(value)) {}\nsimdjson_inline simdjson_result<lasx::ondemand::value_iterator>::simdjson_result(error_code error) noexcept\n : implementation_simdjson_result_base<lasx::ondemand::value_iterator>(error) {}\n\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_ITERATOR_INL_H\n/* end file simdjson/generic/ondemand/value_iterator-inl.h for lasx */\n\n// JSON builder inline definitions\n/* including simdjson/generic/ondemand/json_string_builder-inl.h for lasx: #include \"simdjson/generic/ondemand/json_string_builder-inl.h\" */\n/* begin file simdjson/generic/ondemand/json_string_builder-inl.h for lasx */\n/**\n * This file is part of the builder API. It is temporarily in the ondemand\n * directory but we will move it to a builder directory later.\n */\n#include <array>\n#include <cstring>\n#include <type_traits>\n#ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_STRING_BUILDER_INL_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/builder/json_string_builder.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\n/*\n * Empirically, we have found that an inlined optimization is important for\n * performance. The following macros are not ideal. We should find a better\n * way to inline the code.\n */\n\n#if defined(__SSE2__) || defined(__x86_64__) || defined(__x86_64) || \\\n (defined(_M_AMD64) || defined(_M_X64) || \\\n (defined(_M_IX86_FP) && _M_IX86_FP == 2))\n#ifndef SIMDJSON_EXPERIMENTAL_HAS_SSE2\n#define SIMDJSON_EXPERIMENTAL_HAS_SSE2 1\n#endif\n#endif\n\n#if defined(__aarch64__) || defined(_M_ARM64)\n#ifndef SIMDJSON_EXPERIMENTAL_HAS_NEON\n#define SIMDJSON_EXPERIMENTAL_HAS_NEON 1\n#endif\n#endif\n#if SIMDJSON_EXPERIMENTAL_HAS_NEON\n#include <arm_neon.h>\n#endif\n#if SIMDJSON_EXPERIMENTAL_HAS_SSE2\n#include <emmintrin.h>\n#endif\n\nnamespace simdjson {\nnamespace lasx {\nnamespace builder {\n\nstatic SIMDJSON_CONSTEXPR_LAMBDA std::array<uint8_t, 256>\n json_quotable_character = {\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};\n\n/**\n\nA possible SWAR implementation of has_json_escapable_byte. It is not used\nbecause it is slower than the current implementation. It is kept here for\nreference (to show that we tried it).\n\ninline bool has_json_escapable_byte(uint64_t x) {\n uint64_t is_ascii = 0x8080808080808080ULL & ~x;\n uint64_t xor2 = x ^ 0x0202020202020202ULL;\n uint64_t lt32_or_eq34 = xor2 - 0x2121212121212121ULL;\n uint64_t sub92 = x ^ 0x5C5C5C5C5C5C5C5CULL;\n uint64_t eq92 = (sub92 - 0x0101010101010101ULL);\n return ((lt32_or_eq34 | eq92) & is_ascii) != 0;\n}\n\n**/\n\nSIMDJSON_CONSTEXPR_LAMBDA simdjson_inline bool\nsimple_needs_escaping(std::string_view v) {\n for (char c : v) {\n // a table lookup is faster than a series of comparisons\n if (json_quotable_character[static_cast<uint8_t>(c)]) {\n return true;\n }\n }\n return false;\n}\n\n#if SIMDJSON_EXPERIMENTAL_HAS_NEON\nsimdjson_inline bool fast_needs_escaping(std::string_view view) {\n if (view.size() < 16) {\n return simple_needs_escaping(view);\n }\n size_t i = 0;\n uint8x16_t running = vdupq_n_u8(0);\n uint8x16_t v34 = vdupq_n_u8(34);\n uint8x16_t v92 = vdupq_n_u8(92);\n\n for (; i + 15 < view.size(); i += 16) {\n uint8x16_t word = vld1q_u8((const uint8_t *)view.data() + i);\n running = vorrq_u8(running, vceqq_u8(word, v34));\n running = vorrq_u8(running, vceqq_u8(word, v92));\n running = vorrq_u8(running, vcltq_u8(word, vdupq_n_u8(32)));\n }\n if (i < view.size()) {\n uint8x16_t word =\n vld1q_u8((const uint8_t *)view.data() + view.length() - 16);\n running = vorrq_u8(running, vceqq_u8(word, v34));\n running = vorrq_u8(running, vceqq_u8(word, v92));\n running = vorrq_u8(running, vcltq_u8(word, vdupq_n_u8(32)));\n }\n return vmaxvq_u32(vreinterpretq_u32_u8(running)) != 0;\n}\n#elif SIMDJSON_EXPERIMENTAL_HAS_SSE2\nsimdjson_inline bool fast_needs_escaping(std::string_view view) {\n if (view.size() < 16) {\n return simple_needs_escaping(view);\n }\n size_t i = 0;\n __m128i running = _mm_setzero_si128();\n for (; i + 15 < view.size(); i += 16) {\n\n __m128i word =\n _mm_loadu_si128(reinterpret_cast<const __m128i *>(view.data() + i));\n running = _mm_or_si128(running, _mm_cmpeq_epi8(word, _mm_set1_epi8(34)));\n running = _mm_or_si128(running, _mm_cmpeq_epi8(word, _mm_set1_epi8(92)));\n running = _mm_or_si128(\n running, _mm_cmpeq_epi8(_mm_subs_epu8(word, _mm_set1_epi8(31)),\n _mm_setzero_si128()));\n }\n if (i < view.size()) {\n __m128i word = _mm_loadu_si128(\n reinterpret_cast<const __m128i *>(view.data() + view.length() - 16));\n running = _mm_or_si128(running, _mm_cmpeq_epi8(word, _mm_set1_epi8(34)));\n running = _mm_or_si128(running, _mm_cmpeq_epi8(word, _mm_set1_epi8(92)));\n running = _mm_or_si128(\n running, _mm_cmpeq_epi8(_mm_subs_epu8(word, _mm_set1_epi8(31)),\n _mm_setzero_si128()));\n }\n return _mm_movemask_epi8(running) != 0;\n}\n#else\nsimdjson_inline bool fast_needs_escaping(std::string_view view) {\n return simple_needs_escaping(view);\n}\n#endif\n\nSIMDJSON_CONSTEXPR_LAMBDA inline size_t\nfind_next_json_quotable_character(const std::string_view view,\n size_t location) noexcept {\n\n for (auto pos = view.begin() + location; pos != view.end(); ++pos) {\n if (json_quotable_character[static_cast<uint8_t>(*pos)]) {\n return pos - view.begin();\n }\n }\n return size_t(view.size());\n}\n\nSIMDJSON_CONSTEXPR_LAMBDA static std::string_view control_chars[] = {\n \"\\\\u0000\", \"\\\\u0001\", \"\\\\u0002\", \"\\\\u0003\", \"\\\\u0004\", \"\\\\u0005\", \"\\\\u0006\",\n \"\\\\u0007\", \"\\\\b\", \"\\\\t\", \"\\\\n\", \"\\\\u000b\", \"\\\\f\", \"\\\\r\",\n \"\\\\u000e\", \"\\\\u000f\", \"\\\\u0010\", \"\\\\u0011\", \"\\\\u0012\", \"\\\\u0013\", \"\\\\u0014\",\n \"\\\\u0015\", \"\\\\u0016\", \"\\\\u0017\", \"\\\\u0018\", \"\\\\u0019\", \"\\\\u001a\", \"\\\\u001b\",\n \"\\\\u001c\", \"\\\\u001d\", \"\\\\u001e\", \"\\\\u001f\"};\n\n// All Unicode characters may be placed within the quotation marks, except for\n// the characters that MUST be escaped: quotation mark, reverse solidus, and the\n// control characters (U+0000 through U+001F). There are two-character sequence\n// escape representations of some popular characters:\n// \\\", \\\\, \\b, \\f, \\n, \\r, \\t.\nSIMDJSON_CONSTEXPR_LAMBDA void escape_json_char(char c, char *&out) {\n if (c == '\"') {\n memcpy(out, \"\\\\\\\"\", 2);\n out += 2;\n } else if (c == '\\\\') {\n memcpy(out, \"\\\\\\\\\", 2);\n out += 2;\n } else {\n std::string_view v = control_chars[uint8_t(c)];\n memcpy(out, v.data(), v.size());\n out += v.size();\n }\n}\n\ninline size_t write_string_escaped(const std::string_view input, char *out) {\n size_t mysize = input.size();\n if (!fast_needs_escaping(input)) { // fast path!\n memcpy(out, input.data(), input.size());\n return input.size();\n }\n const char *const initout = out;\n size_t location = find_next_json_quotable_character(input, 0);\n memcpy(out, input.data(), location);\n out += location;\n escape_json_char(input[location], out);\n location += 1;\n while (location < mysize) {\n size_t newlocation = find_next_json_quotable_character(input, location);\n memcpy(out, input.data() + location, newlocation - location);\n out += newlocation - location;\n location = newlocation;\n if (location == mysize) {\n break;\n }\n escape_json_char(input[location], out);\n location += 1;\n }\n return out - initout;\n}\n\nsimdjson_inline string_builder::string_builder(size_t initial_capacity)\n : buffer(new(std::nothrow) char[initial_capacity]), position(0),\n capacity(buffer.get() != nullptr ? initial_capacity : 0),\n is_valid(buffer.get() != nullptr) {}\n\nsimdjson_inline bool string_builder::capacity_check(size_t upcoming_bytes) {\n // We use the convention that when is_valid is false, then the capacity and\n // the position are 0.\n // Most of the time, this function will return true.\n if (simdjson_likely(upcoming_bytes <= capacity - position)) {\n return true;\n }\n // check for overflow, most of the time there is no overflow\n if (simdjson_likely(position + upcoming_bytes < position)) {\n return false;\n }\n // We will rarely get here.\n grow_buffer((std::max)(capacity * 2, position + upcoming_bytes));\n // If the buffer allocation failed, we set is_valid to false.\n return is_valid;\n}\n\nsimdjson_inline void string_builder::grow_buffer(size_t desired_capacity) {\n if (!is_valid) {\n return;\n }\n std::unique_ptr<char[]> new_buffer(new (std::nothrow) char[desired_capacity]);\n if (new_buffer.get() == nullptr) {\n set_valid(false);\n return;\n }\n std::memcpy(new_buffer.get(), buffer.get(), position);\n buffer.swap(new_buffer);\n capacity = desired_capacity;\n}\n\nsimdjson_inline void string_builder::set_valid(bool valid) noexcept {\n if (!valid) {\n is_valid = false;\n capacity = 0;\n position = 0;\n buffer.reset();\n } else {\n is_valid = true;\n }\n}\n\nsimdjson_inline size_t string_builder::size() const noexcept {\n return position;\n}\n\nsimdjson_inline void string_builder::append(char c) noexcept {\n if (capacity_check(1)) {\n buffer.get()[position++] = c;\n }\n}\n\nsimdjson_inline void string_builder::append_null() noexcept {\n constexpr char null_literal[] = \"null\";\n constexpr size_t null_len = sizeof(null_literal) - 1;\n if (capacity_check(null_len)) {\n std::memcpy(buffer.get() + position, null_literal, null_len);\n position += null_len;\n }\n}\n\nsimdjson_inline void string_builder::clear() noexcept {\n position = 0;\n // if it was invalid, we should try to repair it\n if (!is_valid) {\n capacity = 0;\n buffer.reset();\n is_valid = true;\n }\n}\n\nnamespace internal {\n\ntemplate <typename number_type, typename = typename std::enable_if<\n std::is_unsigned<number_type>::value>::type>\nsimdjson_really_inline int int_log2(number_type x) {\n return 63 - leading_zeroes(uint64_t(x) | 1);\n}\n\nsimdjson_really_inline int fast_digit_count_32(uint32_t x) {\n static uint64_t table[] = {\n 4294967296, 8589934582, 8589934582, 8589934582, 12884901788,\n 12884901788, 12884901788, 17179868184, 17179868184, 17179868184,\n 21474826480, 21474826480, 21474826480, 21474826480, 25769703776,\n 25769703776, 25769703776, 30063771072, 30063771072, 30063771072,\n 34349738368, 34349738368, 34349738368, 34349738368, 38554705664,\n 38554705664, 38554705664, 41949672960, 41949672960, 41949672960,\n 42949672960, 42949672960};\n return uint32_t((x + table[int_log2(x)]) >> 32);\n}\n\nsimdjson_really_inline int fast_digit_count_64(uint64_t x) {\n static uint64_t table[] = {9,\n 99,\n 999,\n 9999,\n 99999,\n 999999,\n 9999999,\n 99999999,\n 999999999,\n 9999999999,\n 99999999999,\n 999999999999,\n 9999999999999,\n 99999999999999,\n 999999999999999ULL,\n 9999999999999999ULL,\n 99999999999999999ULL,\n 999999999999999999ULL,\n 9999999999999999999ULL};\n int y = (19 * int_log2(x) >> 6);\n y += x > table[y];\n return y + 1;\n}\n\ntemplate <typename number_type, typename = typename std::enable_if<\n std::is_unsigned<number_type>::value>::type>\nsimdjson_really_inline size_t digit_count(number_type v) noexcept {\n static_assert(sizeof(number_type) == 8 || sizeof(number_type) == 4 ||\n sizeof(number_type) == 2 || sizeof(number_type) == 1,\n \"We only support 8-bit, 16-bit, 32-bit and 64-bit numbers\");\n SIMDJSON_IF_CONSTEXPR(sizeof(number_type) <= 4) {\n return fast_digit_count_32(static_cast<uint32_t>(v));\n }\n else {\n return fast_digit_count_64(static_cast<uint64_t>(v));\n }\n}\nstatic const char decimal_table[200] = {\n 0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x30, 0x33, 0x30, 0x34, 0x30, 0x35,\n 0x30, 0x36, 0x30, 0x37, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x31, 0x31,\n 0x31, 0x32, 0x31, 0x33, 0x31, 0x34, 0x31, 0x35, 0x31, 0x36, 0x31, 0x37,\n 0x31, 0x38, 0x31, 0x39, 0x32, 0x30, 0x32, 0x31, 0x32, 0x32, 0x32, 0x33,\n 0x32, 0x34, 0x32, 0x35, 0x32, 0x36, 0x32, 0x37, 0x32, 0x38, 0x32, 0x39,\n 0x33, 0x30, 0x33, 0x31, 0x33, 0x32, 0x33, 0x33, 0x33, 0x34, 0x33, 0x35,\n 0x33, 0x36, 0x33, 0x37, 0x33, 0x38, 0x33, 0x39, 0x34, 0x30, 0x34, 0x31,\n 0x34, 0x32, 0x34, 0x33, 0x34, 0x34, 0x34, 0x35, 0x34, 0x36, 0x34, 0x37,\n 0x34, 0x38, 0x34, 0x39, 0x35, 0x30, 0x35, 0x31, 0x35, 0x32, 0x35, 0x33,\n 0x35, 0x34, 0x35, 0x35, 0x35, 0x36, 0x35, 0x37, 0x35, 0x38, 0x35, 0x39,\n 0x36, 0x30, 0x36, 0x31, 0x36, 0x32, 0x36, 0x33, 0x36, 0x34, 0x36, 0x35,\n 0x36, 0x36, 0x36, 0x37, 0x36, 0x38, 0x36, 0x39, 0x37, 0x30, 0x37, 0x31,\n 0x37, 0x32, 0x37, 0x33, 0x37, 0x34, 0x37, 0x35, 0x37, 0x36, 0x37, 0x37,\n 0x37, 0x38, 0x37, 0x39, 0x38, 0x30, 0x38, 0x31, 0x38, 0x32, 0x38, 0x33,\n 0x38, 0x34, 0x38, 0x35, 0x38, 0x36, 0x38, 0x37, 0x38, 0x38, 0x38, 0x39,\n 0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x34, 0x39, 0x35,\n 0x39, 0x36, 0x39, 0x37, 0x39, 0x38, 0x39, 0x39,\n};\n} // namespace internal\n\ntemplate <typename number_type, typename>\nsimdjson_inline void string_builder::append(number_type v) noexcept {\n static_assert(std::is_same<number_type, bool>::value ||\n std::is_integral<number_type>::value ||\n std::is_floating_point<number_type>::value,\n \"Unsupported number type\");\n // If C++17 is available, we can 'if constexpr' here.\n SIMDJSON_IF_CONSTEXPR(std::is_same<number_type, bool>::value) {\n if (v) {\n constexpr char true_literal[] = \"true\";\n constexpr size_t true_len = sizeof(true_literal) - 1;\n if (capacity_check(true_len)) {\n std::memcpy(buffer.get() + position, true_literal, true_len);\n position += true_len;\n }\n } else {\n constexpr char false_literal[] = \"false\";\n constexpr size_t false_len = sizeof(false_literal) - 1;\n if (capacity_check(false_len)) {\n std::memcpy(buffer.get() + position, false_literal, false_len);\n position += false_len;\n }\n }\n }\n else SIMDJSON_IF_CONSTEXPR(std::is_unsigned<number_type>::value) {\n constexpr size_t max_number_size = 20;\n if (capacity_check(max_number_size)) {\n using unsigned_type = typename std::make_unsigned<number_type>::type;\n unsigned_type pv = static_cast<unsigned_type>(v);\n size_t dc = internal::digit_count(pv);\n char *write_pointer = buffer.get() + position + dc - 1;\n while (pv >= 100) {\n memcpy(write_pointer - 1, &internal::decimal_table[(pv % 100) * 2], 2);\n write_pointer -= 2;\n pv /= 100;\n }\n if (pv >= 10) {\n *write_pointer-- = char('0' + (pv % 10));\n pv /= 10;\n }\n *write_pointer = char('0' + pv);\n position += dc;\n }\n }\n else SIMDJSON_IF_CONSTEXPR(std::is_integral<number_type>::value) {\n constexpr size_t max_number_size = 20;\n if (capacity_check(max_number_size)) {\n using unsigned_type = typename std::make_unsigned<number_type>::type;\n bool negative = v < 0;\n unsigned_type pv = static_cast<unsigned_type>(v);\n if (negative) {\n pv = 0 - pv; // the 0 is for Microsoft\n }\n size_t dc = internal::digit_count(pv);\n // by always writing the minus sign, we avoid the branch.\n buffer.get()[position] = '-';\n position += negative ? 1 : 0;\n char *write_pointer = buffer.get() + position + dc - 1;\n while (pv >= 100) {\n memcpy(write_pointer - 1, &internal::decimal_table[(pv % 100) * 2], 2);\n write_pointer -= 2;\n pv /= 100;\n }\n if (pv >= 10) {\n *write_pointer-- = char('0' + (pv % 10));\n pv /= 10;\n }\n *write_pointer = char('0' + pv);\n position += dc;\n }\n }\n else SIMDJSON_IF_CONSTEXPR(std::is_floating_point<number_type>::value) {\n constexpr size_t max_number_size = 24;\n if (capacity_check(max_number_size)) {\n // We could specialize for float.\n char *end = simdjson::internal::to_chars(buffer.get() + position, nullptr,\n double(v));\n position = end - buffer.get();\n }\n }\n}\n\nsimdjson_inline void\nstring_builder::escape_and_append(std::string_view input) noexcept {\n // escaping might turn a control character into \\x00xx so 6 characters.\n if (capacity_check(6 * input.size())) {\n position += write_string_escaped(input, buffer.get() + position);\n }\n}\n\nsimdjson_inline void\nstring_builder::escape_and_append_with_quotes(std::string_view input) noexcept {\n // escaping might turn a control character into \\x00xx so 6 characters.\n if (capacity_check(2 + 6 * input.size())) {\n buffer.get()[position++] = '\"';\n position += write_string_escaped(input, buffer.get() + position);\n buffer.get()[position++] = '\"';\n }\n}\n\nsimdjson_inline void\nstring_builder::escape_and_append_with_quotes(char input) noexcept {\n // escaping might turn a control character into \\x00xx so 6 characters.\n if (capacity_check(2 + 6 * 1)) {\n buffer.get()[position++] = '\"';\n std::string_view cinput(&input, 1);\n position += write_string_escaped(cinput, buffer.get() + position);\n buffer.get()[position++] = '\"';\n }\n}\n\nsimdjson_inline void\nstring_builder::escape_and_append_with_quotes(const char *input) noexcept {\n std::string_view cinput(input);\n escape_and_append_with_quotes(cinput);\n}\n#if SIMDJSON_SUPPORTS_CONCEPTS\ntemplate <constevalutil::fixed_string key>\nsimdjson_inline void string_builder::escape_and_append_with_quotes() noexcept {\n escape_and_append_with_quotes(constevalutil::string_constant<key>::value);\n}\n#endif\n\nsimdjson_inline void string_builder::append_raw(const char *c) noexcept {\n size_t len = std::strlen(c);\n append_raw(c, len);\n}\n\nsimdjson_inline void\nstring_builder::append_raw(std::string_view input) noexcept {\n if (capacity_check(input.size())) {\n std::memcpy(buffer.get() + position, input.data(), input.size());\n position += input.size();\n }\n}\n\nsimdjson_inline void string_builder::append_raw(const char *str,\n size_t len) noexcept {\n if (capacity_check(len)) {\n std::memcpy(buffer.get() + position, str, len);\n position += len;\n }\n}\n#if SIMDJSON_SUPPORTS_CONCEPTS\n// Support for optional types (std::optional, etc.)\ntemplate <concepts::optional_type T>\n requires(!require_custom_serialization<T>)\nsimdjson_inline void string_builder::append(const T &opt) {\n if (opt) {\n append(*opt);\n } else {\n append_null();\n }\n}\n\ntemplate <typename T>\n requires(require_custom_serialization<T>)\nsimdjson_inline void string_builder::append(const T &val) {\n serialize(*this, val);\n}\n\ntemplate <typename T>\n requires(std::is_convertible<T, std::string_view>::value ||\n std::is_same<T, const char *>::value)\nsimdjson_inline void string_builder::append(const T &value) {\n escape_and_append_with_quotes(value);\n}\n#endif\n\n#if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS\n// Support for range-based appending (std::ranges::view, etc.)\ntemplate <std::ranges::range R>\n requires(!std::is_convertible<R, std::string_view>::value)\nsimdjson_inline void string_builder::append(const R &range) noexcept {\n auto it = std::ranges::begin(range);\n auto end = std::ranges::end(range);\n if constexpr (concepts::is_pair<typename R::value_type>) {\n start_object();\n\n if (it == end) {\n end_object();\n return; // Handle empty range\n }\n // Append first item without leading comma\n append_key_value(it->first, it->second);\n ++it;\n\n // Append remaining items with preceding commas\n for (; it != end; ++it) {\n append_comma();\n append_key_value(it->first, it->second);\n }\n end_object();\n } else {\n start_array();\n if (it == end) {\n end_array();\n return; // Handle empty range\n }\n\n // Append first item without leading comma\n append(*it);\n ++it;\n\n // Append remaining items with preceding commas\n for (; it != end; ++it) {\n append_comma();\n append(*it);\n }\n end_array();\n }\n}\n\n#endif\n\n#if SIMDJSON_EXCEPTIONS\nsimdjson_inline string_builder::operator std::string() const noexcept(false) {\n return std::string(operator std::string_view());\n}\n\nsimdjson_inline string_builder::operator std::string_view() const\n noexcept(false) simdjson_lifetime_bound {\n return view();\n}\n#endif\n\nsimdjson_inline simdjson_result<std::string_view>\nstring_builder::view() const noexcept {\n if (!is_valid) {\n return simdjson::OUT_OF_CAPACITY;\n }\n return std::string_view(buffer.get(), position);\n}\n\nsimdjson_inline simdjson_result<const char *> string_builder::c_str() noexcept {\n if (capacity_check(1)) {\n buffer.get()[position] = '\\0';\n return buffer.get();\n }\n return simdjson::OUT_OF_CAPACITY;\n}\n\nsimdjson_inline bool string_builder::validate_unicode() const noexcept {\n return simdjson::validate_utf8(buffer.get(), position);\n}\n\nsimdjson_inline void string_builder::start_object() noexcept {\n if (capacity_check(1)) {\n buffer.get()[position++] = '{';\n }\n}\n\nsimdjson_inline void string_builder::end_object() noexcept {\n if (capacity_check(1)) {\n buffer.get()[position++] = '}';\n }\n}\n\nsimdjson_inline void string_builder::start_array() noexcept {\n if (capacity_check(1)) {\n buffer.get()[position++] = '[';\n }\n}\n\nsimdjson_inline void string_builder::end_array() noexcept {\n if (capacity_check(1)) {\n buffer.get()[position++] = ']';\n }\n}\n\nsimdjson_inline void string_builder::append_comma() noexcept {\n if (capacity_check(1)) {\n buffer.get()[position++] = ',';\n }\n}\n\nsimdjson_inline void string_builder::append_colon() noexcept {\n if (capacity_check(1)) {\n buffer.get()[position++] = ':';\n }\n}\n\ntemplate <typename key_type, typename value_type>\nsimdjson_inline void\nstring_builder::append_key_value(key_type key, value_type value) noexcept {\n static_assert(std::is_same<key_type, const char *>::value ||\n std::is_convertible<key_type, std::string_view>::value,\n \"Unsupported key type\");\n escape_and_append_with_quotes(key);\n append_colon();\n SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, std::nullptr_t>::value) {\n append_null();\n }\n else SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, char>::value) {\n escape_and_append_with_quotes(value);\n }\n else SIMDJSON_IF_CONSTEXPR(\n std::is_convertible<value_type, std::string_view>::value) {\n escape_and_append_with_quotes(value);\n }\n else SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, const char *>::value) {\n escape_and_append_with_quotes(value);\n }\n else {\n append(value);\n }\n}\n\n#if SIMDJSON_SUPPORTS_CONCEPTS\ntemplate <constevalutil::fixed_string key, typename value_type>\nsimdjson_inline void\nstring_builder::append_key_value(value_type value) noexcept {\n escape_and_append_with_quotes<key>();\n append_colon();\n SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, std::nullptr_t>::value) {\n append_null();\n }\n else SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, char>::value) {\n escape_and_append_with_quotes(value);\n }\n else SIMDJSON_IF_CONSTEXPR(\n std::is_convertible<value_type, std::string_view>::value) {\n escape_and_append_with_quotes(value);\n }\n else SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, const char *>::value) {\n escape_and_append_with_quotes(value);\n }\n else {\n append(value);\n }\n}\n#endif\n\n} // namespace builder\n} // namespace lasx\n} // namespace simdjson\n\n#endif // SIMDJSON_GENERIC_STRING_BUILDER_INL_H\n/* end file simdjson/generic/ondemand/json_string_builder-inl.h for lasx */\n/* including simdjson/generic/ondemand/json_builder.h for lasx: #include \"simdjson/generic/ondemand/json_builder.h\" */\n/* begin file simdjson/generic/ondemand/json_builder.h for lasx */\n/**\n * This file is part of the builder API. It is temporarily in the ondemand directory\n * but we will move it to a builder directory later.\n */\n#ifndef SIMDJSON_GENERIC_BUILDER_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_STRING_BUILDER_H */\n/* amalgamation skipped (editor-only): #include \"simdjson/generic/builder/json_string_builder.h\" */\n/* amalgamation skipped (editor-only): #include \"simdjson/concepts.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n#if SIMDJSON_STATIC_REFLECTION\n\n#include <charconv>\n#include <cstring>\n#include <meta>\n#include <memory>\n#include <optional>\n#include <string_view>\n#include <type_traits>\n#include <utility>\n// #include <static_reflection> // for std::define_static_string - header not available yet\n\nnamespace simdjson {\nnamespace lasx {\nnamespace builder {\n\ntemplate <class T>\n requires(concepts::container_but_not_string<T> && !require_custom_serialization<T>)\nconstexpr void atom(string_builder &b, const T &t) {\n auto it = t.begin();\n auto end = t.end();\n if (it == end) {\n b.append_raw(\"[]\");\n return;\n }\n b.append('[');\n atom(b, *it);\n ++it;\n for (; it != end; ++it) {\n b.append(',');\n atom(b, *it);\n }\n b.append(']');\n}\n\ntemplate <class T>\n requires(std::is_same_v<T, std::string> ||\n std::is_same_v<T, std::string_view> ||\n std::is_same_v<T, const char *> ||\n std::is_same_v<T, char>)\nconstexpr void atom(string_builder &b, const T &t) {\n b.escape_and_append_with_quotes(t);\n}\n\ntemplate <concepts::string_view_keyed_map T>\n requires(!require_custom_serialization<T>)\nconstexpr void atom(string_builder &b, const T &m) {\n if (m.empty()) {\n b.append_raw(\"{}\");\n return;\n }\n b.append('{');\n bool first = true;\n for (const auto& [key, value] : m) {\n if (!first) {\n b.append(',');\n }\n first = false;\n // Keys must be convertible to string_view per the concept\n b.escape_and_append_with_quotes(key);\n b.append(':');\n atom(b, value);\n }\n b.append('}');\n}\n\n\ntemplate<typename number_type,\n typename = typename std::enable_if<std::is_arithmetic<number_type>::value && !std::is_same_v<number_type, char>>::type>\nconstexpr void atom(string_builder &b, const number_type t) {\n b.append(t);\n}\n\ntemplate <class T>\n requires(std::is_class_v<T> && !concepts::container_but_not_string<T> &&\n !concepts::string_view_keyed_map<T> &&\n !concepts::optional_type<T> &&\n !concepts::smart_pointer<T> &&\n !concepts::appendable_containers<T> &&\n !std::is_same_v<T, std::string> &&\n !std::is_same_v<T, std::string_view> &&\n !std::is_same_v<T, const char*> &&\n !std::is_same_v<T, char> && !require_custom_serialization<T>)\nconstexpr void atom(string_builder &b, const T &t) {\n int i = 0;\n b.append('{');\n template for (constexpr auto dm : std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {\n if (i != 0)\n b.append(',');\n constexpr auto key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(dm)));\n b.append_raw(key);\n b.append(':');\n atom(b, t.[:dm:]);\n i++;\n };\n b.append('}');\n}\n\n// Support for optional types (std::optional, etc.)\ntemplate <concepts::optional_type T>\n requires(!require_custom_serialization<T>)\nconstexpr void atom(string_builder &b, const T &opt) {\n if (opt) {\n atom(b, opt.value());\n } else {\n b.append_raw(\"null\");\n }\n}\n\n// Support for smart pointers (std::unique_ptr, std::shared_ptr, etc.)\ntemplate <concepts::smart_pointer T>\n requires(!require_custom_serialization<T>)\nconstexpr void atom(string_builder &b, const T &ptr) {\n if (ptr) {\n atom(b, *ptr);\n } else {\n b.append_raw(\"null\");\n }\n}\n\n// Support for enums - serialize as string representation using expand approach from P2996R12\ntemplate <typename T>\n requires(std::is_enum_v<T> && !require_custom_serialization<T>)\nvoid atom(string_builder &b, const T &e) {\n#if SIMDJSON_STATIC_REFLECTION\n constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));\n template for (constexpr auto enum_val : enumerators) {\n constexpr auto enum_str = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(enum_val)));\n if (e == [:enum_val:]) {\n b.append_raw(enum_str);\n return;\n }\n };\n // Fallback to integer if enum value not found\n atom(b, static_cast<std::underlying_type_t<T>>(e));\n#else\n // Fallback: serialize as integer if reflection not available\n atom(b, static_cast<std::underlying_type_t<T>>(e));\n#endif\n}\n\n// Support for appendable containers that don't have operator[] (sets, etc.)\ntemplate <concepts::appendable_containers T>\n requires(!concepts::container_but_not_string<T> && !concepts::string_view_keyed_map<T> &&\n !concepts::optional_type<T> && !concepts::smart_pointer<T> &&\n !std::is_same_v<T, std::string> &&\n !std::is_same_v<T, std::string_view> && !std::is_same_v<T, const char*> && !require_custom_serialization<T>)\nconstexpr void atom(string_builder &b, const T &container) {\n if (container.empty()) {\n b.append_raw(\"[]\");\n return;\n }\n b.append('[');\n bool first = true;\n for (const auto& item : container) {\n if (!first) {\n b.append(',');\n }\n first = false;\n atom(b, item);\n }\n b.append(']');\n}\n\n// append functions that delegate to atom functions for primitive types\ntemplate <class T>\n requires(std::is_arithmetic_v<T> && !std::is_same_v<T, char>)\nvoid append(string_builder &b, const T &t) {\n atom(b, t);\n}\n\ntemplate <class T>\n requires(std::is_same_v<T, std::string> ||\n std::is_same_v<T, std::string_view> ||\n std::is_same_v<T, const char *> ||\n std::is_same_v<T, char>)\nvoid append(string_builder &b, const T &t) {\n atom(b, t);\n}\n\ntemplate <concepts::optional_type T>\n requires(!require_custom_serialization<T>)\nvoid append(string_builder &b, const T &t) {\n atom(b, t);\n}\n\ntemplate <concepts::smart_pointer T>\n requires(!require_custom_serialization<T>)\nvoid append(string_builder &b, const T &t) {\n atom(b, t);\n}\n\ntemplate <concepts::appendable_containers T>\n requires(!concepts::container_but_not_string<T> && !concepts::string_view_keyed_map<T> &&\n !concepts::optional_type<T> && !concepts::smart_pointer<T> &&\n !std::is_same_v<T, std::string> &&\n !std::is_same_v<T, std::string_view> && !std::is_same_v<T, const char*> && !require_custom_serialization<T>)\nvoid append(string_builder &b, const T &t) {\n atom(b, t);\n}\n\ntemplate <concepts::string_view_keyed_map T>\n requires(!require_custom_serialization<T>)\nvoid append(string_builder &b, const T &t) {\n atom(b, t);\n}\n\n// works for struct\ntemplate <class Z>\n requires(std::is_class_v<Z> && !concepts::container_but_not_string<Z> &&\n !concepts::string_view_keyed_map<Z> &&\n !concepts::optional_type<Z> &&\n !concepts::smart_pointer<Z> &&\n !concepts::appendable_containers<Z> &&\n !std::is_same_v<Z, std::string> &&\n !std::is_same_v<Z, std::string_view> &&\n !std::is_same_v<Z, const char*> &&\n !std::is_same_v<Z, char> && !require_custom_serialization<Z>)\nvoid append(string_builder &b, const Z &z) {\n int i = 0;\n b.append('{');\n template for (constexpr auto dm : std::define_static_array(std::meta::nonstatic_data_members_of(^^Z, std::meta::access_context::unchecked()))) {\n if (i != 0)\n b.append(',');\n constexpr auto key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(dm)));\n b.append_raw(key);\n b.append(':');\n atom(b, z.[:dm:]);\n i++;\n };\n b.append('}');\n}\n\n// works for container that have begin() and end() iterators\ntemplate <class Z>\n requires(concepts::container_but_not_string<Z> && !require_custom_serialization<Z>)\nvoid append(string_builder &b, const Z &z) {\n auto it = z.begin();\n auto end = z.end();\n if (it == end) {\n b.append_raw(\"[]\");\n return;\n }\n b.append('[');\n atom(b, *it);\n ++it;\n for (; it != end; ++it) {\n b.append(',');\n atom(b, *it);\n }\n b.append(']');\n}\n\ntemplate <class Z>\n requires (require_custom_serialization<Z>)\nvoid append(string_builder &b, const Z &z) {\n b.append(z);\n}\n\n\ntemplate <class Z>\nsimdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {\n string_builder b(initial_capacity);\n append(b, z);\n std::string_view s;\n if(auto e = b.view().get(s); e) { return e; }\n return std::string(s);\n}\n\ntemplate <class Z>\nsimdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {\n string_builder b(initial_capacity);\n append(b, z);\n std::string_view view;\n if(auto e = b.view().get(view); e) { return e; }\n s.assign(view);\n return SUCCESS;\n}\n\ntemplate <class Z>\nstring_builder& operator<<(string_builder& b, const Z& z) {\n append(b, z);\n return b;\n}\n\n// extract_from: Serialize only specific fields from a struct to JSON\ntemplate<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\nvoid extract_from(string_builder &b, const T &obj) {\n // Helper to check if a field name matches any of the requested fields\n auto should_extract = [](std::string_view field_name) constexpr -> bool {\n return ((FieldNames.view() == field_name) || ...);\n };\n\n b.append('{');\n bool first = true;\n\n // Iterate through all members of T using reflection\n template for (constexpr auto mem : std::define_static_array(\n std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {\n\n if constexpr (std::meta::is_public(mem)) {\n constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));\n\n // Only serialize this field if it's in our list of requested fields\n if constexpr (should_extract(key)) {\n if (!first) {\n b.append(',');\n }\n first = false;\n\n // Serialize the key\n constexpr auto quoted_key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(mem)));\n b.append_raw(quoted_key);\n b.append(':');\n\n // Serialize the value\n atom(b, obj.[:mem:]);\n }\n }\n };\n\n b.append('}');\n}\n\ntemplate<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\nsimdjson_warn_unused simdjson_result<std::string> extract_from(const T &obj, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {\n string_builder b(initial_capacity);\n extract_from<FieldNames...>(b, obj);\n std::string_view s;\n if(auto e = b.view().get(s); e) { return e; }\n return std::string(s);\n}\n\n} // namespace builder\n} // namespace lasx\n// Alias the function template to 'to' in the global namespace\ntemplate <class Z>\nsimdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = lasx::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {\n lasx::builder::string_builder b(initial_capacity);\n lasx::builder::append(b, z);\n std::string_view s;\n if(auto e = b.view().get(s); e) { return e; }\n return std::string(s);\n}\ntemplate <class Z>\nsimdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = lasx::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {\n lasx::builder::string_builder b(initial_capacity);\n lasx::builder::append(b, z);\n std::string_view view;\n if(auto e = b.view().get(view); e) { return e; }\n s.assign(view);\n return SUCCESS;\n}\n// Global namespace function for extract_from\ntemplate<constevalutil::fixed_string... FieldNames, typename T>\n requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))\nsimdjson_warn_unused simdjson_result<std::string> extract_from(const T &obj, size_t initial_capacity = lasx::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {\n lasx::builder::string_builder b(initial_capacity);\n lasx::builder::extract_from<FieldNames...>(b, obj);\n std::string_view s;\n if(auto e = b.view().get(s); e) { return e; }\n return std::string(s);\n}\n\n} // namespace simdjson\n\n#endif // SIMDJSON_STATIC_REFLECTION\n\n#endif\n/* end file simdjson/generic/ondemand/json_builder.h for lasx */\n\n// JSON path accessor (compile-time) - must be after inline definitions\n/* including simdjson/generic/ondemand/compile_time_accessors.h for lasx: #include \"simdjson/generic/ondemand/compile_time_accessors.h\" */\n/* begin file simdjson/generic/ondemand/compile_time_accessors.h for lasx */\n/**\n * Compile-time JSON Path and JSON Pointer accessors using C++26 reflection (P2996)\n *\n * This file validates JSON paths/pointers against struct definitions at compile time\n * and generates optimized accessor code with zero runtime overhead.\n *\n * ## How It Works\n *\n * **Compile Time**: Path is parsed, validated against struct, types are checked\n * **Runtime**: Direct navigation with no parsing or validation overhead\n *\n * Example:\n * ```cpp\n * struct User { std::string name; std::vector<std::string> emails; };\n *\n * std::string email;\n * path_accessor<User, \".emails[0]\">::extract_field(doc, email);\n *\n * // Compile time validates:\n * // 1. User has \"emails\" field\n * // 2. \"emails\" is array-like\n * // 3. Element type is std::string\n * // 4. static_assert(^^std::string == ^^std::string)\n *\n * // Runtime just navigates:\n * // doc.get_object().find_field(\"emails\").get_array().at(0).get(email)\n * ```\n *\n * ## Key Reflection APIs\n *\n * - `^^Type`: Reflect operator, converts type to std::meta::info\n * - `std::meta::nonstatic_data_members_of(type)`: Get all fields of a struct\n * - `std::meta::identifier_of(member)`: Get field name as string_view\n * - `std::meta::type_of(member)`: Get reflected type of a field\n * - `std::meta::is_array_type(type)`: Check if C-style array\n * - `std::meta::remove_extent(array)`: Extract element type from array\n * - `std::meta::members_of(type)`: Get all members including typedefs\n * - `std::meta::is_type(member)`: Check if member is a type (vs field)\n *\n * All operations execute at compile time in consteval contexts.\n */\n#ifndef SIMDJSON_GENERIC_ONDEMAND_COMPILE_TIME_ACCESSORS_H\n\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_COMPILE_TIME_ACCESSORS_H */\n/* amalgamation skipped (editor-only): */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\n// Arguably, we should just check SIMDJSON_STATIC_REFLECTION since it\n// is unlikely that we will have reflection support without concepts support.\n#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION\n\n#include <string_view>\n#include <cstddef>\n#include <array>\n\nnamespace simdjson {\nnamespace lasx {\nnamespace ondemand {\n/***\n * JSONPath implementation for compile-time access\n * RFC 9535 JSONPath: Query Expressions for JSON, https://www.rfc-editor.org/rfc/rfc9535\n */\nnamespace json_path {\n\n// Note: value type must be fully defined before this header is included\n// This is ensured by including this in amalgamated.h after value-inl.h\n\nusing ::simdjson::lasx::ondemand::value;\n\n// Path step types\nenum class step_type {\n field, // .field_name or [\"field_name\"]\n array_index // [index]\n};\n\n// Represents a single step in a JSON path\ntemplate<std::size_t N>\nstruct path_step {\n step_type type;\n char key[N]; // Field name (empty for array indices)\n std::size_t index; // Array index (0 for field access)\n\n constexpr path_step(step_type t, const char (&k)[N], std::size_t idx = 0)\n : type(t), index(idx) {\n for (std::size_t i = 0; i < N; ++i) {\n key[i] = k[i];\n }\n }\n\n constexpr std::string_view key_view() const {\n return {key, N - 1};\n }\n};\n\n// Helper to create field step\ntemplate<std::size_t N>\nconsteval auto make_field_step(const char (&name)[N]) {\n return path_step<N>(step_type::field, name, 0);\n}\n\n// Helper to create array index step\nconsteval auto make_index_step(std::size_t idx) {\n return path_step<1>(step_type::array_index, \"\", idx);\n}\n\n// Parse state for compile-time JSON path parsing\nstruct parse_result {\n bool success;\n std::size_t pos;\n std::string_view error_msg;\n};\n\n// Compile-time JSON path parser\n// Supports subset: .field, [\"field\"], [index], nested combinations\ntemplate<constevalutil::fixed_string Path>\nstruct json_path_parser {\n static constexpr std::string_view path_str = Path.view();\n\n // Skip leading $ if present\n static consteval std::size_t skip_root() {\n if (!path_str.empty() && path_str[0] == '$') {\n return 1;\n }\n return 0;\n }\n\n // Count the number of steps in the path at compile time\n static consteval std::size_t count_steps() {\n std::size_t count = 0;\n std::size_t i = skip_root();\n\n while (i < path_str.size()) {\n if (path_str[i] == '.') {\n // Field access: .field\n ++i;\n if (i >= path_str.size()) break;\n\n // Skip field name\n while (i < path_str.size() && path_str[i] != '.' && path_str[i] != '[') {\n ++i;\n }\n ++count;\n } else if (path_str[i] == '[') {\n // Array or bracket notation\n ++i;\n if (i >= path_str.size()) break;\n\n if (path_str[i] == '\"' || path_str[i] == '\\'') {\n // Field access: [\"field\"] or ['field']\n char quote = path_str[i];\n ++i;\n while (i < path_str.size() && path_str[i] != quote) {\n ++i;\n }\n if (i < path_str.size()) ++i; // skip closing quote\n if (i < path_str.size() && path_str[i] == ']') ++i;\n } else {\n // Array index: [0], [123]\n while (i < path_str.size() && path_str[i] != ']') {\n ++i;\n }\n if (i < path_str.size()) ++i; // skip ]\n }\n ++count;\n } else {\n ++i;\n }\n }\n\n return count;\n }\n\n // Parse a field name at compile time\n static consteval std::size_t parse_field_name(std::size_t start, char* out, std::size_t max_len) {\n std::size_t len = 0;\n std::size_t i = start;\n\n while (i < path_str.size() && path_str[i] != '.' && path_str[i] != '[' && len < max_len - 1) {\n out[len++] = path_str[i++];\n }\n out[len] = '\\0';\n return i;\n }\n\n // Parse an array index at compile time\n static consteval std::pair<std::size_t, std::size_t> parse_array_index(std::size_t start) {\n std::size_t index = 0;\n std::size_t i = start;\n\n while (i < path_str.size() && path_str[i] >= '0' && path_str[i] <= '9') {\n index = index * 10 + (path_str[i] - '0');\n ++i;\n }\n\n return {i, index};\n }\n};\n\n// Compile-time path accessor generator\ntemplate<typename T, constevalutil::fixed_string Path>\nstruct path_accessor {\n using value = ::simdjson::lasx::ondemand::value;\n\n static constexpr auto parser = json_path_parser<Path>();\n static constexpr std::size_t num_steps = parser.count_steps();\n static constexpr std::string_view path_view = Path.view();\n\n // Compile-time accessor generation\n // If T is a struct, validates the path at compile time\n // If T is void, skips validation\n template<typename DocOrValue>\n static inline simdjson_result<value> access(DocOrValue& doc_or_val) noexcept {\n // Validate path at compile time if T is a struct\n if constexpr (std::is_class_v<T>) {\n constexpr bool path_valid = validate_path();\n static_assert(path_valid, \"JSON path does not match struct definition\");\n }\n\n // Parse the path at compile time to build access steps\n return access_impl<parser.skip_root()>(doc_or_val.get_value());\n }\n\n // Extract value at path directly into target with compile-time type validation\n // Example: std::string name; path_accessor<User, \".name\">::extract_field(doc, name);\n template<typename DocOrValue, typename FieldType>\n static inline error_code extract_field(DocOrValue& doc_or_val, FieldType& target) noexcept {\n static_assert(std::is_class_v<T>, \"extract_field requires T to be a struct type for validation\");\n\n // Validate path exists in struct definition\n constexpr bool path_valid = validate_path();\n static_assert(path_valid, \"JSON path does not match struct definition\");\n\n // Get the type at the end of the path\n constexpr auto final_type = get_final_type();\n\n // Verify target type matches the field type\n static_assert(final_type == ^^FieldType, \"Target type does not match the field type at the path\");\n\n // All validation done at compile time - just navigate and extract\n auto json_value = access_impl<parser.skip_root()>(doc_or_val.get_value());\n if (json_value.error()) return json_value.error();\n\n return json_value.get(target);\n }\n\nprivate:\n // Get the final type by walking the path through the struct type\n template<typename U = T>\n static consteval std::enable_if_t<std::is_class_v<U>, std::meta::info> get_final_type() {\n auto current_type = ^^T;\n std::size_t i = parser.skip_root();\n\n while (i < path_view.size()) {\n if (path_view[i] == '.') {\n // .field syntax\n ++i;\n std::size_t field_start = i;\n while (i < path_view.size() && path_view[i] != '.' && path_view[i] != '[') {\n ++i;\n }\n\n std::string_view field_name = path_view.substr(field_start, i - field_start);\n\n auto members = std::meta::nonstatic_data_members_of(\n current_type, std::meta::access_context::unchecked()\n );\n\n for (auto mem : members) {\n if (std::meta::identifier_of(mem) == field_name) {\n current_type = std::meta::type_of(mem);\n break;\n }\n }\n\n } else if (path_view[i] == '[') {\n ++i;\n if (i >= path_view.size()) break;\n\n if (path_view[i] == '\"' || path_view[i] == '\\'') {\n // [\"field\"] syntax\n char quote = path_view[i];\n ++i;\n std::size_t field_start = i;\n while (i < path_view.size() && path_view[i] != quote) {\n ++i;\n }\n\n std::string_view field_name = path_view.substr(field_start, i - field_start);\n if (i < path_view.size()) ++i; // skip quote\n if (i < path_view.size() && path_view[i] == ']') ++i;\n\n auto members = std::meta::nonstatic_data_members_of(\n current_type, std::meta::access_context::unchecked()\n );\n\n for (auto mem : members) {\n if (std::meta::identifier_of(mem) == field_name) {\n current_type = std::meta::type_of(mem);\n break;\n }\n }\n\n } else {\n // [index] syntax - extract element type\n while (i < path_view.size() && path_view[i] >= '0' && path_view[i] <= '9') {\n ++i;\n }\n if (i < path_view.size() && path_view[i] == ']') ++i;\n\n current_type = get_element_type_reflected(current_type);\n }\n } else {\n ++i;\n }\n }\n\n return current_type;\n }\n\nprivate:\n // Walk path and extract directly into final field using compile-time reflection\n template<std::meta::info CurrentType, std::size_t PathPos, typename TargetType>\n static inline error_code extract_with_reflection(simdjson_result<value> current, TargetType& target_ref) noexcept {\n if (current.error()) return current.error();\n\n // Base case: end of path - extract into target\n if constexpr (PathPos >= path_view.size()) {\n return current.get(target_ref);\n }\n // Field access: .field_name\n else if constexpr (path_view[PathPos] == '.') {\n constexpr auto field_info = parse_next_field(PathPos);\n constexpr std::string_view field_name = std::get<0>(field_info);\n constexpr std::size_t next_pos = std::get<1>(field_info);\n\n constexpr auto member_info = find_member_by_name(CurrentType, field_name);\n static_assert(member_info != ^^void, \"Field not found in struct\");\n\n constexpr auto member_type = std::meta::type_of(member_info);\n\n auto obj_result = current.get_object();\n if (obj_result.error()) return obj_result.error();\n auto obj = obj_result.value_unsafe();\n auto field_value = obj.find_field_unordered(field_name);\n\n if constexpr (next_pos >= path_view.size()) {\n return field_value.get(target_ref);\n } else {\n return extract_with_reflection<member_type, next_pos>(field_value, target_ref);\n }\n }\n // Bracket notation: [index] or [\"field\"]\n else if constexpr (path_view[PathPos] == '[') {\n constexpr auto bracket_info = parse_bracket(PathPos);\n constexpr bool is_field = std::get<0>(bracket_info);\n constexpr std::size_t next_pos = std::get<2>(bracket_info);\n\n if constexpr (is_field) {\n constexpr std::string_view field_name = std::get<1>(bracket_info);\n constexpr auto member_info = find_member_by_name(CurrentType, field_name);\n static_assert(member_info != ^^void, \"Field not found in struct\");\n constexpr auto member_type = std::meta::type_of(member_info);\n\n auto obj_result = current.get_object();\n if (obj_result.error()) return obj_result.error();\n auto obj = obj_result.value_unsafe();\n auto field_value = obj.find_field_unordered(field_name);\n\n if constexpr (next_pos >= path_view.size()) {\n return field_value.get(target_ref);\n } else {\n return extract_with_reflection<member_type, next_pos>(field_value, target_ref);\n }\n } else {\n constexpr std::size_t index = std::get<3>(bracket_info);\n constexpr auto elem_type = get_element_type_reflected(CurrentType);\n static_assert(elem_type != ^^void, \"Could not determine array element type\");\n\n auto arr_result = current.get_array();\n if (arr_result.error()) return arr_result.error();\n auto arr = arr_result.value_unsafe();\n auto elem_value = arr.at(index);\n\n if constexpr (next_pos >= path_view.size()) {\n return elem_value.get(target_ref);\n } else {\n return extract_with_reflection<elem_type, next_pos>(elem_value, target_ref);\n }\n }\n }\n // Skip unexpected characters and continue\n else {\n return extract_with_reflection<CurrentType, PathPos + 1>(current, target_ref);\n }\n }\n\n // Find member by name in reflected type\n static consteval std::meta::info find_member_by_name(std::meta::info type_refl, std::string_view name) {\n auto members = std::meta::nonstatic_data_members_of(type_refl, std::meta::access_context::unchecked());\n for (auto mem : members) {\n if (std::meta::identifier_of(mem) == name) {\n return mem;\n }\n }\n }\n\n // Generate compile-time accessor code by walking the path\n template<std::size_t PathPos>\n static inline simdjson_result<value> access_impl(simdjson_result<value> current) noexcept {\n if (current.error()) return current;\n\n if constexpr (PathPos >= path_view.size()) {\n return current;\n } else if constexpr (path_view[PathPos] == '.') {\n constexpr auto field_info = parse_next_field(PathPos);\n constexpr std::string_view field_name = std::get<0>(field_info);\n constexpr std::size_t next_pos = std::get<1>(field_info);\n\n auto obj_result = current.get_object();\n if (obj_result.error()) return obj_result.error();\n\n auto obj = obj_result.value_unsafe();\n auto next_value = obj.find_field_unordered(field_name);\n\n return access_impl<next_pos>(next_value);\n\n } else if constexpr (path_view[PathPos] == '[') {\n constexpr auto bracket_info = parse_bracket(PathPos);\n constexpr bool is_field = std::get<0>(bracket_info);\n constexpr std::size_t next_pos = std::get<2>(bracket_info);\n\n if constexpr (is_field) {\n constexpr std::string_view field_name = std::get<1>(bracket_info);\n\n auto obj_result = current.get_object();\n if (obj_result.error()) return obj_result.error();\n\n auto obj = obj_result.value_unsafe();\n auto next_value = obj.find_field_unordered(field_name);\n\n return access_impl<next_pos>(next_value);\n\n } else {\n constexpr std::size_t index = std::get<3>(bracket_info);\n\n auto arr_result = current.get_array();\n if (arr_result.error()) return arr_result.error();\n\n auto arr = arr_result.value_unsafe();\n auto next_value = arr.at(index);\n\n return access_impl<next_pos>(next_value);\n }\n } else {\n return access_impl<PathPos + 1>(current);\n }\n }\n\n // Parse next field name\n static consteval auto parse_next_field(std::size_t start) {\n std::size_t i = start + 1;\n std::size_t field_start = i;\n while (i < path_view.size() && path_view[i] != '.' && path_view[i] != '[') {\n ++i;\n }\n std::string_view field_name = path_view.substr(field_start, i - field_start);\n return std::make_tuple(field_name, i);\n }\n\n // Parse bracket notation: returns (is_field, field_name, next_pos, index)\n static consteval auto parse_bracket(std::size_t start) {\n std::size_t i = start + 1; // skip '['\n\n if (i < path_view.size() && (path_view[i] == '\"' || path_view[i] == '\\'')) {\n // Field access\n char quote = path_view[i];\n ++i;\n std::size_t field_start = i;\n while (i < path_view.size() && path_view[i] != quote) {\n ++i;\n }\n std::string_view field_name = path_view.substr(field_start, i - field_start);\n if (i < path_view.size()) ++i; // skip closing quote\n if (i < path_view.size() && path_view[i] == ']') ++i;\n\n return std::make_tuple(true, field_name, i, std::size_t(0));\n } else {\n // Array index\n std::size_t index = 0;\n while (i < path_view.size() && path_view[i] >= '0' && path_view[i] <= '9') {\n index = index * 10 + (path_view[i] - '0');\n ++i;\n }\n if (i < path_view.size() && path_view[i] == ']') ++i;\n\n return std::make_tuple(false, std::string_view{}, i, index);\n }\n }\n\npublic:\n // Check if reflected type is array-like (C-style array or indexable container)\n // Uses reflection to test: 1) std::meta::is_array_type() for C arrays\n // 2) std::meta::substitute() to test concepts::indexable_container concept\n static consteval bool is_array_like_reflected(std::meta::info type_reflection) {\n if (std::meta::is_array_type(type_reflection)) {\n return true;\n }\n\n if (std::meta::can_substitute(^^concepts::indexable_container_v, {type_reflection})) {\n return std::meta::extract<bool>(std::meta::substitute(^^concepts::indexable_container_v, {type_reflection}));\n }\n return false;\n }\n\n // Extract element type from reflected array or container\n // For C arrays: uses std::meta::remove_extent()\n // For containers: finds value_type member using std::meta::members_of()\n static consteval std::meta::info get_element_type_reflected(std::meta::info type_reflection) {\n if (std::meta::is_array_type(type_reflection)) {\n return std::meta::remove_extent(type_reflection);\n }\n\n auto members = std::meta::members_of(type_reflection, std::meta::access_context::unchecked());\n for (auto mem : members) {\n if (std::meta::is_type(mem)) {\n auto name = std::meta::identifier_of(mem);\n if (name == \"value_type\") {\n return mem;\n }\n }\n }\n return ^^void;\n }\n\nprivate:\n // Check if type has member with given name\n template<typename Type>\n static consteval bool has_member(std::string_view member_name) {\n constexpr auto members = std::meta::nonstatic_data_members_of(^^Type, std::meta::access_context::unchecked());\n for (auto mem : members) {\n if (std::meta::identifier_of(mem) == member_name) {\n return true;\n }\n }\n return false;\n }\n\n // Get type of member by name\n template<typename Type>\n static consteval auto get_member_type(std::string_view member_name) {\n constexpr auto members = std::meta::nonstatic_data_members_of(^^Type, std::meta::access_context::unchecked());\n for (auto mem : members) {\n if (std::meta::identifier_of(mem) == member_name) {\n return std::meta::type_of(mem);\n }\n }\n return ^^void;\n }\n\n // Check if non-reflected type is array-like\n template<typename Type>\n static consteval bool is_container_type() {\n using BaseType = std::remove_cvref_t<Type>;\n if constexpr (requires { typename BaseType::value_type; }) {\n return true;\n }\n if constexpr (std::is_array_v<BaseType>) {\n return true;\n }\n return false;\n }\n\n // Extract element type from non-reflected container\n template<typename Type>\n using extract_element_type = std::conditional_t<\n requires { typename std::remove_cvref_t<Type>::value_type; },\n typename std::remove_cvref_t<Type>::value_type,\n std::conditional_t<\n std::is_array_v<std::remove_cvref_t<Type>>,\n std::remove_extent_t<std::remove_cvref_t<Type>>,\n void\n >\n >;\n\n // Validate path matches struct definition\n static consteval bool validate_path() {\n if constexpr (!std::is_class_v<T>) {\n return true;\n }\n\n auto current_type = ^^T;\n std::size_t i = parser.skip_root();\n\n while (i < path_view.size()) {\n if (path_view[i] == '.') {\n ++i;\n std::size_t field_start = i;\n while (i < path_view.size() && path_view[i] != '.' && path_view[i] != '[') {\n ++i;\n }\n\n std::string_view field_name = path_view.substr(field_start, i - field_start);\n\n bool found = false;\n auto members = std::meta::nonstatic_data_members_of(current_type, std::meta::access_context::unchecked());\n\n for (auto mem : members) {\n if (std::meta::identifier_of(mem) == field_name) {\n current_type = std::meta::type_of(mem);\n found = true;\n break;\n }\n }\n\n if (!found) {\n return false;\n }\n\n } else if (path_view[i] == '[') {\n ++i;\n if (i >= path_view.size()) return false;\n\n if (path_view[i] == '\"' || path_view[i] == '\\'') {\n char quote = path_view[i];\n ++i;\n std::size_t field_start = i;\n while (i < path_view.size() && path_view[i] != quote) {\n ++i;\n }\n\n std::string_view field_name = path_view.substr(field_start, i - field_start);\n if (i < path_view.size()) ++i;\n if (i < path_view.size() && path_view[i] == ']') ++i;\n\n bool found = false;\n auto members = std::meta::nonstatic_data_members_of(current_type, std::meta::access_context::unchecked());\n\n for (auto mem : members) {\n if (std::meta::identifier_of(mem) == field_name) {\n current_type = std::meta::type_of(mem);\n found = true;\n break;\n }\n }\n\n if (!found) {\n return false;\n }\n\n } else {\n while (i < path_view.size() && path_view[i] >= '0' && path_view[i] <= '9') {\n ++i;\n }\n\n if (i < path_view.size() && path_view[i] == ']') ++i;\n\n if (!is_array_like_reflected(current_type)) {\n return false;\n }\n\n auto new_type = get_element_type_reflected(current_type);\n\n if (new_type == ^^void) {\n return false;\n }\n\n current_type = new_type;\n }\n } else {\n ++i;\n }\n }\n\n return true;\n }\n};\n\n// Compile-time path accessor with validation\ntemplate<typename T, constevalutil::fixed_string Path, typename DocOrValue>\ninline simdjson_result<::simdjson::lasx::ondemand::value> at_path_compiled(DocOrValue& doc_or_val) noexcept {\n using accessor = path_accessor<T, Path>;\n return accessor::access(doc_or_val);\n}\n\n// Overload without type parameter (no validation)\ntemplate<constevalutil::fixed_string Path, typename DocOrValue>\ninline simdjson_result<::simdjson::lasx::ondemand::value> at_path_compiled(DocOrValue& doc_or_val) noexcept {\n using accessor = path_accessor<void, Path>;\n return accessor::access(doc_or_val);\n}\n\n// ============================================================================\n// JSON Pointer Compile-Time Support (RFC 6901)\n// ============================================================================\n\n// JSON Pointer parser: /field/0/nested (slash-separated)\ntemplate<constevalutil::fixed_string Pointer>\nstruct json_pointer_parser {\n static constexpr std::string_view pointer_str = Pointer.view();\n\n // Unescape token: ~0 -> ~, ~1 -> /\n static consteval void unescape_token(std::string_view src, char* dest, std::size_t& out_len) {\n out_len = 0;\n for (std::size_t i = 0; i < src.size(); ++i) {\n if (src[i] == '~' && i + 1 < src.size()) {\n if (src[i + 1] == '0') {\n dest[out_len++] = '~';\n ++i;\n } else if (src[i + 1] == '1') {\n dest[out_len++] = '/';\n ++i;\n } else {\n dest[out_len++] = src[i];\n }\n } else {\n dest[out_len++] = src[i];\n }\n }\n }\n\n // Check if token is numeric\n static consteval bool is_numeric(std::string_view token) {\n if (token.empty()) return false;\n if (token[0] == '0' && token.size() > 1) return false;\n for (char c : token) {\n if (c < '0' || c > '9') return false;\n }\n return true;\n }\n\n // Parse numeric token to index\n static consteval std::size_t parse_index(std::string_view token) {\n std::size_t result = 0;\n for (char c : token) {\n result = result * 10 + (c - '0');\n }\n return result;\n }\n\n // Count tokens in pointer\n static consteval std::size_t count_tokens() {\n if (pointer_str.empty() || pointer_str == \"/\") return 0;\n\n std::size_t count = 0;\n std::size_t pos = pointer_str[0] == '/' ? 1 : 0;\n\n while (pos < pointer_str.size()) {\n ++count;\n std::size_t next_slash = pointer_str.find('/', pos);\n if (next_slash == std::string_view::npos) break;\n pos = next_slash + 1;\n }\n\n return count;\n }\n\n // Get Nth token\n static consteval std::string_view get_token(std::size_t token_index) {\n std::size_t pos = pointer_str[0] == '/' ? 1 : 0;\n std::size_t current_token = 0;\n\n while (current_token < token_index) {\n std::size_t next_slash = pointer_str.find('/', pos);\n pos = next_slash + 1;\n ++current_token;\n }\n\n std::size_t token_end = pointer_str.find('/', pos);\n if (token_end == std::string_view::npos) token_end = pointer_str.size();\n\n return pointer_str.substr(pos, token_end - pos);\n }\n};\n\n// JSON Pointer accessor\ntemplate<typename T, constevalutil::fixed_string Pointer>\nstruct pointer_accessor {\n using parser = json_pointer_parser<Pointer>;\n static constexpr std::string_view pointer_view = Pointer.view();\n static constexpr std::size_t token_count = parser::count_tokens();\n\n // Validate pointer against struct definition\n static consteval bool validate_pointer() {\n if constexpr (!std::is_class_v<T>) {\n return true;\n }\n\n auto current_type = ^^T;\n std::size_t pos = pointer_view[0] == '/' ? 1 : 0;\n\n while (pos < pointer_view.size()) {\n // Extract token up to next /\n std::size_t token_end = pointer_view.find('/', pos);\n if (token_end == std::string_view::npos) token_end = pointer_view.size();\n\n std::string_view token = pointer_view.substr(pos, token_end - pos);\n\n if (parser::is_numeric(token)) {\n if (!path_accessor<T, Pointer>::is_array_like_reflected(current_type)) {\n return false;\n }\n current_type = path_accessor<T, Pointer>::get_element_type_reflected(current_type);\n } else {\n bool found = false;\n auto members = std::meta::nonstatic_data_members_of(current_type, std::meta::access_context::unchecked());\n\n for (auto mem : members) {\n if (std::meta::identifier_of(mem) == token) {\n current_type = std::meta::type_of(mem);\n found = true;\n break;\n }\n }\n\n if (!found) return false;\n }\n\n pos = token_end + 1;\n }\n\n return true;\n }\n\n // Recursive accessor\n template<std::size_t TokenIndex>\n static inline simdjson_result<value> access_impl(simdjson_result<value> current) noexcept {\n if constexpr (TokenIndex >= token_count) {\n return current;\n } else {\n constexpr std::string_view token = parser::get_token(TokenIndex);\n\n if constexpr (parser::is_numeric(token)) {\n constexpr std::size_t index = parser::parse_index(token);\n auto arr = current.get_array().value_unsafe();\n auto next_value = arr.at(index);\n return access_impl<TokenIndex + 1>(next_value);\n } else {\n auto obj = current.get_object().value_unsafe();\n auto next_value = obj.find_field_unordered(token);\n return access_impl<TokenIndex + 1>(next_value);\n }\n }\n }\n\n // Access JSON value at pointer\n template<typename DocOrValue>\n static inline simdjson_result<value> access(DocOrValue& doc_or_val) noexcept {\n if constexpr (std::is_class_v<T>) {\n constexpr bool pointer_valid = validate_pointer();\n static_assert(pointer_valid, \"JSON Pointer does not match struct definition\");\n }\n\n if (pointer_view.empty() || pointer_view == \"/\") {\n if constexpr (requires { doc_or_val.get_value(); }) {\n return doc_or_val.get_value();\n } else {\n return doc_or_val;\n }\n }\n\n simdjson_result<value> current = doc_or_val.get_value();\n return access_impl<0>(current);\n }\n\n // Extract value at pointer directly into target with type validation\n template<typename DocOrValue, typename FieldType>\n static inline error_code extract_field(DocOrValue& doc_or_val, FieldType& target) noexcept {\n static_assert(std::is_class_v<T>, \"extract_field requires T to be a struct type for validation\");\n\n constexpr bool pointer_valid = validate_pointer();\n static_assert(pointer_valid, \"JSON Pointer does not match struct definition\");\n\n constexpr auto final_type = get_final_type();\n static_assert(final_type == ^^FieldType, \"Target type does not match the field type at the pointer\");\n\n simdjson_result<value> current_value = doc_or_val.get_value();\n auto json_value = access_impl<0>(current_value);\n if (json_value.error()) return json_value.error();\n\n return json_value.get(target);\n }\n\nprivate:\n // Get final type by walking pointer through struct\n template<typename U = T>\n static consteval std::enable_if_t<std::is_class_v<U>, std::meta::info> get_final_type() {\n auto current_type = ^^T;\n std::size_t pos = pointer_view[0] == '/' ? 1 : 0;\n\n while (pos < pointer_view.size()) {\n std::size_t token_end = pointer_view.find('/', pos);\n if (token_end == std::string_view::npos) token_end = pointer_view.size();\n\n std::string_view token = pointer_view.substr(pos, token_end - pos);\n\n if (parser::is_numeric(token)) {\n current_type = path_accessor<T, \"\">::get_element_type_reflected(current_type);\n } else {\n auto members = std::meta::nonstatic_data_members_of(current_type, std::meta::access_context::unchecked());\n\n for (auto mem : members) {\n if (std::meta::identifier_of(mem) == token) {\n current_type = std::meta::type_of(mem);\n break;\n }\n }\n }\n\n pos = token_end + 1;\n }\n\n return current_type;\n }\n};\n\n// Compile-time JSON Pointer accessor with validation\ntemplate<typename T, constevalutil::fixed_string Pointer, typename DocOrValue>\ninline simdjson_result<::simdjson::lasx::ondemand::value> at_pointer_compiled(DocOrValue& doc_or_val) noexcept {\n using accessor = pointer_accessor<T, Pointer>;\n return accessor::access(doc_or_val);\n}\n\n// Overload without type parameter (no validation)\ntemplate<constevalutil::fixed_string Pointer, typename DocOrValue>\ninline simdjson_result<::simdjson::lasx::ondemand::value> at_pointer_compiled(DocOrValue& doc_or_val) noexcept {\n using accessor = pointer_accessor<void, Pointer>;\n return accessor::access(doc_or_val);\n}\n\n} // namespace json_path\n} // namespace ondemand\n} // namespace lasx\n} // namespace simdjson\n\n#endif // SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION\n#endif // SIMDJSON_GENERIC_ONDEMAND_COMPILE_TIME_ACCESSORS_H\n\n/* end file simdjson/generic/ondemand/compile_time_accessors.h for lasx */\n\n/* end file simdjson/generic/ondemand/amalgamated.h for lasx */\n/* including simdjson/lasx/end.h: #include \"simdjson/lasx/end.h\" */\n/* begin file simdjson/lasx/end.h */\n/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */\n/* amalgamation skipped (editor-only): #include \"simdjson/lasx/base.h\" */\n/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */\n\n#undef SIMDJSON_SKIP_BACKSLASH_SHORT_CIRCUIT\n/* undefining SIMDJSON_IMPLEMENTATION from \"lasx\" */\n#undef SIMDJSON_IMPLEMENTATION\n/* end file simdjson/lasx/end.h */\n\n#endif // SIMDJSON_LASX_ONDEMAND_H\n/* end file simdjson/lasx/ondemand.h */\n#else\n#error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION\n#endif\n\n/* undefining SIMDJSON_CONDITIONAL_INCLUDE */\n#undef SIMDJSON_CONDITIONAL_INCLUDE\n\nnamespace simdjson {\n /**\n * @copydoc simdjson::SIMDJSON_BUILTIN_IMPLEMENTATION::ondemand\n */\n namespace ondemand = SIMDJSON_BUILTIN_IMPLEMENTATION::ondemand;\n} // namespace simdjson\n\n#endif // SIMDJSON_BUILTIN_ONDEMAND_H\n/* end file simdjson/builtin/ondemand.h */\n\nnamespace simdjson {\n /**\n * @copydoc simdjson::builtin::ondemand\n */\n namespace ondemand = builtin::ondemand;\n /**\n * @copydoc simdjson::builtin::builder\n */\n namespace builder = builtin::builder;\n\n#if SIMDJSON_STATIC_REFLECTION\n /**\n * Create a JSON string from any user-defined type using static reflection.\n * Only available when SIMDJSON_STATIC_REFLECTION is enabled.\n */\n template<typename T>\n requires(!std::same_as<T, builtin::ondemand::document> &&\n !std::same_as<T, builtin::ondemand::value> &&\n !std::same_as<T, builtin::ondemand::object> &&\n !std::same_as<T, builtin::ondemand::array>)\n inline std::string to_json_string(const T& obj) {\n builder::string_builder str_builder;\n append(str_builder, obj);\n std::string_view view;\n if (str_builder.view().get(view) == SUCCESS) {\n return std::string(view);\n }\n return \"\";\n }\n#endif\n\n} // namespace simdjson\n\n#endif // SIMDJSON_ONDEMAND_H\n/* end file simdjson/ondemand.h */\n/* including simdjson/convert.h: #include \"simdjson/convert.h\" */\n/* begin file simdjson/convert.h */\n\n#ifndef SIMDJSON_CONVERT_H\n#define SIMDJSON_CONVERT_H\n\n/* skipped duplicate #include \"simdjson/ondemand.h\" */\n#include <optional>\n\n#if SIMDJSON_SUPPORTS_CONCEPTS\n\n\nnamespace simdjson {\nnamespace convert {\nnamespace internal {\n\n/**\n * A utility class for automatically parsing JSON documents.\n * This template is NOT part of our public API.\n * It is subject to changes.\n * @private\n */\ntemplate <typename parser_type = ondemand::parser*>\nstruct auto_parser {\nprivate:\n\tparser_type m_parser;\n\tondemand::document m_doc;\n\terror_code m_error{SUCCESS};\n\n\ttemplate <typename T>\n\tstatic constexpr bool is_nothrow_gettable = requires(ondemand::document doc) {\n\t\t{ doc.get<T>() } noexcept;\n\t};\npublic:\n\texplicit auto_parser(parser_type &&parser, ondemand::document &&doc) noexcept requires(!std::is_pointer_v<parser_type>);\n\texplicit auto_parser(parser_type &&parser, padded_string_view const str) noexcept requires(!std::is_pointer_v<parser_type>);\n\texplicit auto_parser(std::remove_pointer_t<parser_type> &parser, ondemand::document &&doc) noexcept requires(std::is_pointer_v<parser_type>);\n\texplicit auto_parser(std::remove_pointer_t<parser_type> &parser, padded_string_view const str) noexcept requires(std::is_pointer_v<parser_type>);\n\texplicit auto_parser(padded_string_view const str) noexcept requires(std::is_pointer_v<parser_type>);\n\texplicit auto_parser(parser_type parser, ondemand::document &&doc) noexcept requires(std::is_pointer_v<parser_type>);\n\t\tauto_parser(auto_parser const &) = delete;\n\t\tauto_parser &operator=(auto_parser const &) = delete;\n\t\tauto_parser(auto_parser &&) noexcept = default;\n\t\tauto_parser &operator=(auto_parser &&) noexcept = default;\n\t\t~auto_parser() = default;\n\n\tsimdjson_warn_unused std::remove_pointer_t<parser_type> &parser() noexcept;\n\n\ttemplate <typename T>\n\tsimdjson_warn_unused simdjson_inline simdjson_result<T> result() noexcept(is_nothrow_gettable<T>);\n\ttemplate <typename T>\n\tsimdjson_warn_unused simdjson_inline error_code get(T &value) && noexcept(is_nothrow_gettable<T>);\n\n\n\tsimdjson_warn_unused simdjson_inline simdjson_result<ondemand::array> array() noexcept;\n\tsimdjson_warn_unused simdjson_inline simdjson_result<ondemand::object> object() noexcept;\n\tsimdjson_warn_unused simdjson_inline simdjson_result<ondemand::number> number() noexcept;\n\n\n#if SIMDJSON_EXCEPTIONS\n\ttemplate <typename T>\n\tsimdjson_warn_unused simdjson_inline explicit(false) operator T() noexcept(false);\n#endif // SIMDJSON_EXCEPTIONS\n\n\ttemplate <typename T>\n\tsimdjson_warn_unused simdjson_inline std::optional<T> optional() noexcept(is_nothrow_gettable<T>);\n};\n\n\n/**\n * A utility class for adapting values for the `auto_parser`.\n * This template is not part of our public API. It is subject to changes.\n * @private\n */\ntemplate <typename T = void>\nstruct to_adaptor {\n\tT operator()(simdjson_result<ondemand::value> &val) const noexcept;\n\tauto operator()(padded_string_view const str) const noexcept;\n\tauto operator()(ondemand::parser &parser, padded_string_view const str) const noexcept;\n\t// The std::string is padded with reserve to ensure there is enough space for padding.\n\t// Some sanitizers may not like this, so you can use simdjson::pad instead.\n\t// simdjson::from(simdjson::pad(str))\n\tauto operator()(std::string str) const noexcept;\n\tauto operator()(ondemand::parser &parser, std::string str) const noexcept;\n};\n// deduction guide\nauto_parser(padded_string_view const str) -> auto_parser<ondemand::parser*>;\n} // namespace internal\n} // namespace convert\n\n/**\n * The simdjson::from instance is EXPERIMENTAL AND SUBJECT TO CHANGES.\n *\n * The `from` instance is a utility adaptor for parsing JSON strings into objects.\n * It provides a convenient way to convert JSON data into C++ objects using the `auto_parser`.\n *\n * Example usage:\n *\n * ```cpp\n * std::map<std::string, std::string> obj =\n * simdjson::from(R\"({\"key\": \"value\"})\"_padded);\n * ```\n *\n * This will parse the JSON string and return an object representation. By default, we\n * use the simdjson::ondemand::parser::get_parser() instance. A parser instance should\n * be used for just one document at a time.\n *\n * You can also pass you own parser instance:\n * ```cpp\n * simdjson::ondemand::parser parser;\n * std::map<std::string, std::string> obj =\n * simdjson::from(parser, R\"({\"key\": \"value\"})\"_padded);\n * ```\n * The parser instance can be reused.\n *\n * This functionality requires C++20 or better.\n */\nstatic constexpr convert::internal::to_adaptor<> from{};\n\n} // namespace simdjson\n\n#endif // SIMDJSON_SUPPORTS_CONCEPTS\n#endif // SIMDJSON_CONVERT_H\n/* end file simdjson/convert.h */\n/* including simdjson/convert-inl.h: #include \"simdjson/convert-inl.h\" */\n/* begin file simdjson/convert-inl.h */\n\n#ifndef SIMDJSON_CONVERT_INL_H\n#define SIMDJSON_CONVERT_INL_H\n\n/* skipped duplicate #include \"simdjson/convert.h\" */\n#if SIMDJSON_SUPPORTS_CONCEPTS\nnamespace simdjson {\nnamespace convert {\nnamespace internal {\n// auto_parser method definitions\ntemplate <typename parser_type>\ninline auto_parser<parser_type>::auto_parser(parser_type &&parser, ondemand::document &&doc) noexcept requires(!std::is_pointer_v<parser_type>)\n : m_parser{std::move(parser)}, m_doc{std::move(doc)} {}\n\ntemplate <typename parser_type>\ninline auto_parser<parser_type>::auto_parser(parser_type &&parser, padded_string_view const str) noexcept requires(!std::is_pointer_v<parser_type>)\n : m_parser{std::move(parser)}, m_doc{}, m_error{SUCCESS} {\n m_error = m_parser.iterate(str).get(m_doc);\n}\n\ntemplate <typename parser_type>\ninline auto_parser<parser_type>::auto_parser(std::remove_pointer_t<parser_type> &parser, ondemand::document &&doc) noexcept requires(std::is_pointer_v<parser_type>)\n : m_parser{&parser}, m_doc{std::move(doc)} {}\n\ntemplate <typename parser_type>\ninline auto_parser<parser_type>::auto_parser(std::remove_pointer_t<parser_type> &parser, padded_string_view const str) noexcept requires(std::is_pointer_v<parser_type>)\n : m_parser{&parser}, m_doc{}, m_error{SUCCESS} {\n m_error = m_parser->iterate(str).get(m_doc);\n}\n\ntemplate <typename parser_type>\ninline auto_parser<parser_type>::auto_parser(padded_string_view const str) noexcept requires(std::is_pointer_v<parser_type>)\n : auto_parser{ondemand::parser::get_parser(), str} {}\n\ntemplate <typename parser_type>\ninline auto_parser<parser_type>::auto_parser(parser_type parser, ondemand::document &&doc) noexcept requires(std::is_pointer_v<parser_type>)\n : auto_parser{*parser, std::move(doc)} {}\n\n\n\n\n\ntemplate <typename parser_type>\ninline std::remove_pointer_t<parser_type> &auto_parser<parser_type>::parser() noexcept {\n if constexpr (std::is_pointer_v<parser_type>) {\n return *m_parser;\n } else {\n return m_parser;\n }\n}\n\ntemplate <typename parser_type>\ntemplate <typename T>\ninline simdjson_result<T> auto_parser<parser_type>::result() noexcept(is_nothrow_gettable<T>) {\n if (m_error != SUCCESS) {\n return m_error;\n }\n return m_doc.get<T>();\n}\n\ntemplate <typename parser_type>\ntemplate <typename T>\nsimdjson_warn_unused simdjson_inline error_code auto_parser<parser_type>::get(T &value) && noexcept(is_nothrow_gettable<T>) {\n return result<T>().get(value);\n}\n\ntemplate <typename parser_type>\ninline simdjson_result<ondemand::array> auto_parser<parser_type>::array() noexcept {\n return result<ondemand::array>();\n}\n\ntemplate <typename parser_type>\ninline simdjson_result<ondemand::object> auto_parser<parser_type>::object() noexcept {\n return result<ondemand::object>();\n}\n\ntemplate <typename parser_type>\ninline simdjson_result<ondemand::number> auto_parser<parser_type>::number() noexcept {\n return result<ondemand::number>();\n}\n\n#if SIMDJSON_EXCEPTIONS\ntemplate <typename parser_type>\ntemplate <typename T>\ninline auto_parser<parser_type>::operator T() noexcept(false) {\n if (m_error != SUCCESS) {\n throw simdjson_error(m_error);\n }\n return m_doc.get<T>();\n}\n#endif // SIMDJSON_EXCEPTIONS\n\ntemplate <typename parser_type>\ntemplate <typename T>\ninline std::optional<T> auto_parser<parser_type>::optional() noexcept(is_nothrow_gettable<T>) {\n if (m_error != SUCCESS) {\n return std::nullopt;\n }\n T value;\n if (m_doc.get<T>().get(value)) [[unlikely]] {\n return std::nullopt;\n }\n return {std::move(value)};\n}\n\n// to_adaptor method definitions\ntemplate <typename T>\ninline T to_adaptor<T>::operator()(simdjson_result<ondemand::value> &val) const noexcept {\n return val.get<T>();\n}\n\ntemplate <typename T>\ninline auto to_adaptor<T>::operator()(padded_string_view const str) const noexcept {\n return auto_parser<ondemand::parser *>{str};\n}\n\ntemplate <typename T>\ninline auto to_adaptor<T>::operator()(ondemand::parser &parser, padded_string_view const str) const noexcept {\n return auto_parser<ondemand::parser *>{parser, str};\n}\n\ntemplate <typename T>\ninline auto to_adaptor<T>::operator()(std::string str) const noexcept {\n return auto_parser<ondemand::parser *>{pad_with_reserve(str)};\n}\n\ntemplate <typename T>\ninline auto to_adaptor<T>::operator()(ondemand::parser &parser, std::string str) const noexcept {\n return auto_parser<ondemand::parser *>{parser, pad_with_reserve(str)};\n}\n} // namespace internal\n} // namespace convert\n} // namespace simdjson\n#endif // SIMDJSON_SUPPORTS_CONCEPTS\n#endif // SIMDJSON_CONVERT_INL_H\n/* end file simdjson/convert-inl.h */\n\n// Compile-time JSON parsing (C++26 P2996 reflection)\n/* including simdjson/compile_time_json.h: #include \"simdjson/compile_time_json.h\" */\n/* begin file simdjson/compile_time_json.h */\n/**\n * @file compile_time_json.h\n * @brief Compile-time JSON parsing using C++26 reflection with\n * std::meta::substitute()\n */\n\n#ifndef SIMDJSON_GENERIC_COMPILE_TIME_JSON_H\n#define SIMDJSON_GENERIC_COMPILE_TIME_JSON_H\n\n#if SIMDJSON_STATIC_REFLECTION\n\n#include <algorithm>\n#include <array>\n#include <charconv>\n#include <cstdint>\n#include <expected>\n#include <meta>\n#include <string>\n#include <string_view>\n#include <vector>\n\nnamespace simdjson {\nnamespace compile_time {\n\n/**\n * @brief Compile-time JSON parser. This function parses the provided JSON\n * string at compile time and returns a custom struct type representing the JSON\n * object.\n *\n * We have a few limitations which trigger compile-time errors if violated:\n * - Only JSON objects and arrays are supported at the top level (no primitives).\n * We will lift this limitation in the future.\n * - Strings are represented using the const char * in UTF-8, but they must not\n * contain embedded nulls. We would prefer to represent them as std::string or\n * std::string_view, and hope to do so in the future.\n * - Heterogeneous arrays are not supported yet. E.g., you need to have arrays of\n * all integers, or all strings, all floats, all compatible objects, etc.\n * For example, the following is accepted:\n * [\n * { \"name\": \"Alice\", \"age\": 30 },\n * { \"name\": \"Bob\", \"age\": 25 },\n * { \"name\": \"Charlie\", \"age\": 35 }\n * ]\n * but the following is not:\n * [\n * { \"name\": \"Alice\", \"age\": 30 },\n * \"Just a string\",\n * 42,\n * { \"name\": \"Charlie\", \"age\": 35 }\n * ]\n *\n * We may support heterogeneous arrays in the future with std::variant types.\n * - We parse the first JSON document encountered in the string. Trailing\n * characters are ignored. Thus if your JSON begins with {\"a\":1}, everything\n * after the closing } is ignored. This limitation will be lifted in the future,\n * reporting an error.\n *\n * These limitations are safe in the sense that they result in compile-time errors.\n * Thus you will not get truncated strings or imprecise floats silently.\n *\n * This function is subject to change in the future.\n */\ntemplate <constevalutil::fixed_string json_str> consteval auto parse_json();\n\n} // namespace compile_time\n} // namespace simdjson\n\n\ntemplate <simdjson::constevalutil::fixed_string str>\nconsteval auto operator \"\"_json() {\n return simdjson::compile_time::parse_json<str>();\n}\n\n#endif // SIMDJSON_STATIC_REFLECTION\n#endif // SIMDJSON_GENERIC_COMPILE_TIME_JSON_H\n/* end file simdjson/compile_time_json.h */\n/* including simdjson/compile_time_json-inl.h: #include \"simdjson/compile_time_json-inl.h\" */\n/* begin file simdjson/compile_time_json-inl.h */\n/**\n * @file compile_time_json-inl.h\n * @brief Implementation details for compile-time JSON parsing\n *\n * This file contains inline implementations and helper utilities for\n * compile-time JSON parsing. Currently, the main implementation is\n * self-contained in the header.\n */\n\n#ifndef SIMDJSON_GENERIC_COMPILE_TIME_JSON_INL_H\n\n#if SIMDJSON_STATIC_REFLECTION\n\n/* skipped duplicate #include \"simdjson/compile_time_json.h\" */\n#include <array>\n#include <cstdint>\n#include <meta>\n#include <string_view>\n\n#include <algorithm>\n#include <array>\n#include <charconv>\n#include <cstdint>\n#include <expected>\n#include <meta>\n#include <string>\n#include <string_view>\n#include <vector>\n\n#define simdjson_consteval_error(...) \\\n { \\\n std::abort(); \\\n }\n\nnamespace simdjson {\nnamespace compile_time {\n\n/**\n * Namespace for number parsing utilities.\n * We seek to provide exact compile-time number parsing functions.\n * That is not trivial, but thankfully we can reuse much of the existing\n * simdjson functionality.\n * Importantly, it is not a trivial matter to provide correct rounding\n * for floating-point numbers at compile-time. The fast_float library\n * does it well.\n */\nnamespace number_parsing {\n\n// Counts the number of leading zeros in a 64-bit integer.\nconsteval int leading_zeroes(uint64_t input_num, int last_bit = 0) {\n if (input_num & uint64_t(0xffffffff00000000)) {\n input_num >>= 32;\n last_bit |= 32;\n }\n if (input_num & uint64_t(0xffff0000)) {\n input_num >>= 16;\n last_bit |= 16;\n }\n if (input_num & uint64_t(0xff00)) {\n input_num >>= 8;\n last_bit |= 8;\n }\n if (input_num & uint64_t(0xf0)) {\n input_num >>= 4;\n last_bit |= 4;\n }\n if (input_num & uint64_t(0xc)) {\n input_num >>= 2;\n last_bit |= 2;\n }\n if (input_num & uint64_t(0x2)) { /* input_num >>= 1; */\n last_bit |= 1;\n }\n return 63 - last_bit;\n}\n// Multiplies two 32-bit unsigned integers and returns a 64-bit result.\nconsteval uint64_t emulu(uint32_t x, uint32_t y) { return x * (uint64_t)y; }\nconsteval uint64_t umul128_generic(uint64_t ab, uint64_t cd, uint64_t *hi) {\n uint64_t ad = emulu((uint32_t)(ab >> 32), (uint32_t)cd);\n uint64_t bd = emulu((uint32_t)ab, (uint32_t)cd);\n uint64_t adbc = ad + emulu((uint32_t)ab, (uint32_t)(cd >> 32));\n uint64_t adbc_carry = (uint64_t)(adbc < ad);\n uint64_t lo = bd + (adbc << 32);\n *hi = emulu((uint32_t)(ab >> 32), (uint32_t)(cd >> 32)) + (adbc >> 32) +\n (adbc_carry << 32) + (uint64_t)(lo < bd);\n return lo;\n}\n\n// Represents a 128-bit unsigned integer as two 64-bit parts.\n// We have a value128 struct elsewhere in the simdjson, but we\n// use a separate one here for clarity.\nstruct value128 {\n uint64_t low;\n uint64_t high;\n\n constexpr value128(uint64_t _low, uint64_t _high) : low(_low), high(_high) {}\n constexpr value128() : low(0), high(0) {}\n};\n\n// Multiplies two 64-bit integers and returns a 128-bit result as value128.\nconsteval value128 full_multiplication(uint64_t a, uint64_t b) {\n value128 answer;\n answer.low = umul128_generic(a, b, &answer.high);\n return answer;\n}\n\n// Converts mantissa and exponent to a double, considering the sign.\nconsteval double to_double(uint64_t mantissa, int64_t exponent, bool negative) {\n uint64_t sign_bit = negative ? (1ULL << 63) : 0;\n uint64_t exponent_bits = (uint64_t(exponent) & 0x7FF) << 52;\n uint64_t bits = sign_bit | exponent_bits | (mantissa & ((1ULL << 52) - 1));\n return std::bit_cast<double>(bits);\n}\n\n// Attempts to compute i * 10^(power) exactly; and if \"negative\" is\n// true, negate the result.\n// Returns true on success, false on failure.\n// Failure suggests and invalid input or out-of-range result.\nconsteval bool compute_float_64(int64_t power, uint64_t i, bool negative,\n double &d) {\n if (i == 0) {\n d = negative ? -0.0 : 0.0;\n return true;\n }\n int64_t exponent = (((152170 + 65536) * power) >> 16) + 1024 + 63;\n int lz = leading_zeroes(i);\n i <<= lz;\n const uint32_t index =\n 2 * uint32_t(power - simdjson::internal::smallest_power);\n value128 firstproduct = full_multiplication(\n i, simdjson::internal::powers_template<>::power_of_five_128[index]);\n if ((firstproduct.high & 0x1FF) == 0x1FF) {\n value128 secondproduct = full_multiplication(\n i, simdjson::internal::powers_template<>::power_of_five_128[index + 1]);\n firstproduct.low += secondproduct.high;\n if (secondproduct.high > firstproduct.low) {\n firstproduct.high++;\n }\n }\n uint64_t lower = firstproduct.low;\n uint64_t upper = firstproduct.high;\n uint64_t upperbit = upper >> 63;\n uint64_t mantissa = upper >> (upperbit + 9);\n lz += int(1 ^ upperbit);\n int64_t real_exponent = exponent - lz;\n if (real_exponent <= 0) {\n if (-real_exponent + 1 >= 64) {\n d = negative ? -0.0 : 0.0;\n return true;\n }\n mantissa >>= -real_exponent + 1;\n mantissa += (mantissa & 1);\n mantissa >>= 1;\n real_exponent = (mantissa < (uint64_t(1) << 52)) ? 0 : 1;\n d = to_double(mantissa, real_exponent, negative);\n return true;\n }\n if ((lower <= 1) && (power >= -4) && (power <= 23) && ((mantissa & 3) == 1)) {\n if ((mantissa << (upperbit + 64 - 53 - 2)) == upper) {\n mantissa &= ~1;\n }\n }\n mantissa += mantissa & 1;\n mantissa >>= 1;\n if (mantissa >= (1ULL << 53)) {\n mantissa = (1ULL << 52);\n real_exponent++;\n }\n mantissa &= ~(1ULL << 52);\n if (real_exponent > 2046) {\n return false;\n }\n d = to_double(mantissa, real_exponent, negative);\n return true;\n}\n\n// Parses a single digit character and updates the integer value.\nconsteval bool parse_digit(const char c, uint64_t &i) {\n const uint8_t digit = static_cast<uint8_t>(c - '0');\n if (digit > 9) {\n return false;\n }\n i = 10 * i + digit;\n return true;\n}\n\n// Parses a JSON float from a string starting at src.\n// Returns the parsed double and the number of characters consumed.\nconsteval std::pair<double, size_t> parse_double(const char *src,\n const char *end) {\n auto get_value = [&](const char *pointer) -> char {\n if (pointer == end) {\n return '\\0';\n }\n return *pointer;\n };\n const char *srcinit = src;\n bool negative = (get_value(src) == '-');\n src += uint8_t(negative);\n uint64_t i = 0;\n const char *p = src;\n p += parse_digit(get_value(p), i);\n bool leading_zero = (i == 0);\n while (parse_digit(get_value(p), i)) {\n p++;\n }\n if (p == src) {\n simdjson_consteval_error(\"Invalid float value\");\n }\n if ((leading_zero && p != src + 1)) {\n simdjson_consteval_error(\"Invalid float value\");\n }\n int64_t exponent = 0;\n bool overflow;\n if (get_value(p) == '.') {\n p++;\n const char *start_decimal_digits = p;\n if (!parse_digit(get_value(p), i)) {\n simdjson_consteval_error(\"Invalid float value\");\n } // no decimal digits\n p++;\n while (parse_digit(get_value(p), i)) {\n p++;\n }\n exponent = -(p - start_decimal_digits);\n overflow = p - src - 1 > 19;\n if (overflow && leading_zero) {\n const char *start_digits = src + 2;\n while (get_value(start_digits) == '0') {\n start_digits++;\n }\n overflow = p - start_digits > 19;\n }\n } else {\n overflow = p - src > 19;\n }\n if (overflow) {\n simdjson_consteval_error(\n \"Overflow while computing the float value: too many digits\");\n }\n if (get_value(p) == 'e' || get_value(p) == 'E') {\n p++;\n bool exp_neg = get_value(p) == '-';\n p += exp_neg || get_value(p) == '+';\n uint64_t exp = 0;\n const char *start_exp_digits = p;\n while (parse_digit(get_value(p), exp)) {\n p++;\n }\n if (p - start_exp_digits == 0 || p - start_exp_digits > 19) {\n simdjson_consteval_error(\"Invalid float value\");\n }\n exponent += exp_neg ? 0 - exp : exp;\n }\n\n overflow = overflow || exponent < simdjson::internal::smallest_power ||\n exponent > simdjson::internal::largest_power;\n if (overflow) {\n simdjson_consteval_error(\"Overflow while computing the float value\");\n }\n double d;\n if (!compute_float_64(exponent, i, negative, d)) {\n simdjson_consteval_error(\"Overflow while computing the float value\");\n }\n return {d, size_t(p - srcinit)};\n}\n} // namespace number_parsing\n\n// JSON string may contain embedded nulls, and C++26 reflection does not yet\n// support std::string_view as a data member type. As a workaround, we define\n// a custom type that holds a const char* and a size.\ntemplate <char... Vals> struct fixed_json_string {\n // Statically-allocated array to hold the characters and a null terminator\n static constexpr char inner_data[] = {Vals..., '\\0'};\n\n // Constant for the length of the string view (excluding the null terminator)\n static constexpr std::size_t inner_size = sizeof...(Vals);\n\n // The std::string_view over the data.\n // We use data and size to avoid including the null terminator in the view.\n static constexpr std::string_view view = {inner_data, inner_size};\n\n constexpr operator std::string_view() { return view; }\n constexpr const char *c_str() { return view.data(); }\n constexpr const char *data() { return view.data(); }\n constexpr size_t size() { return view.size(); }\n};\n\nconsteval std::meta::info to_fixed_json_string(std::string_view in) {\n std::vector<std::meta::info> Args = {};\n for (char c : in) {\n Args.push_back(std::meta::reflect_constant(c));\n }\n return std::meta::substitute(^^fixed_json_string, Args);\n}\n\n/**\n * @brief Helper struct for substitute() pattern\n */\ntemplate <std::meta::info... meta_info> struct type_builder {\n struct constructed_type;\n consteval {\n std::meta::define_aggregate(^^constructed_type, {\n meta_info...});\n }\n};\n\n/**\n * @brief Type alias for the generated struct\n * Usage:\n * using struct = class_type<std::meta::data_member_spec(^^int;, {.name =\n * \"x\"}),std::meta::data_member_spec(^^float, {.name = \"y\"})>;\n */\ntemplate <std::meta::info... meta_info>\nusing class_type = type_builder<meta_info...>::constructed_type;\n\n/**\n */\n\n/**\n * @brief Variable template for constructing instances with values\n */\ntemplate <typename T, auto... Vs> constexpr auto construct_from = T{Vs...};\n\n// in JSON, there are only a few whitespace characters that are allowed\n// outside of objects, arrays, strings, and numbers.\n[[nodiscard]] constexpr bool is_whitespace(char c) {\n return c == ' ' || c == '\\n' || c == '\\t' || c == '\\r';\n};\n\n[[nodiscard]] constexpr std::string_view trim_whitespace(std::string_view str) {\n size_t start = 0;\n size_t end = str.size();\n\n while (start < end && is_whitespace(str[start])) {\n start++;\n }\n while (end > start && is_whitespace(str[end - 1])) {\n end--;\n }\n return str.substr(start, end - start);\n}\n\n// Forward declaration\nconsteval std::pair<std::meta::info, size_t>\nparse_json_object_impl(std::string_view json);\n\n///////////////////////////////////////////////////\n/// NUMBER PARSING\n///////////////////////////////////////////////////\n\n// Parses a JSON number from a string view.\n// Returns the number of characters consumed and the parsed value\n// as a variant of int64_t, uint64_t, or double.\n[[nodiscard]] consteval size_t\nparse_number(std::string_view json,\n std::variant<int64_t, uint64_t, double> &out) {\n if (json.empty()) {\n simdjson_consteval_error(\"Empty string is not a valid JSON number\");\n }\n if (json[0] == '+') {\n simdjson_consteval_error(\"Invalid number: leading '+' sign is not allowed\");\n }\n // Compute the range and determine the type.\n auto it = json.begin();\n if (it != json.end() && (*it == '-')) {\n it++;\n }\n while (it != json.end() && (*it >= '0' && *it <= '9')) {\n it++;\n }\n bool is_float = false;\n if (it != json.end() && (*it == '.' || *it == 'e' || *it == 'E')) {\n is_float = true;\n if (*it == '.') {\n it++;\n while (it != json.end() && (*it >= '0' && *it <= '9')) {\n it++;\n }\n }\n if (it != json.end() && (*it == 'e' || *it == 'E')) {\n it++;\n if (it != json.end() && (*it == '+' || *it == '-')) {\n it++;\n }\n while (it != json.end() && (*it >= '0' && *it <= '9')) {\n it++;\n }\n }\n }\n size_t scope = it - json.begin();\n\n bool is_negative = json[0] == '-';\n // Note that we consider -0 to be an integer unless it has a decimal point or\n // exponent.\n if (is_float) {\n // It would be cool to use std::from_chars in a consteval context, but it is\n // not supported yet for floating point types. :-(\n auto [value, offset] =\n number_parsing::parse_double(json.data(), json.data() + json.size());\n if (offset != scope) {\n simdjson_consteval_error(\n \"Internal error: cannot agree on the character range of the float\");\n }\n out = value;\n return offset;\n } else if (is_negative) {\n int64_t int_value = 0;\n std::from_chars_result res =\n std::from_chars(json.data(), json.data() + json.size(), int_value);\n if (res.ec == std::errc()) {\n out = int_value;\n if ((res.ptr - json.data()) != scope) {\n simdjson_consteval_error(\n \"Internal error: cannot agree on the character range of the float\");\n }\n return (res.ptr - json.data());\n } else {\n simdjson_consteval_error(\"Invalid integer value\");\n }\n } else {\n uint64_t uint_value = 0;\n std::from_chars_result res =\n std::from_chars(json.data(), json.data() + json.size(), uint_value);\n if (res.ec == std::errc()) {\n out = uint_value;\n if ((res.ptr - json.data()) != scope) {\n simdjson_consteval_error(\n \"Internal error: cannot agree on the character range of the float\");\n }\n return (res.ptr - json.data());\n } else {\n simdjson_consteval_error(\"Invalid unsigned integer value\");\n }\n }\n}\n\n////////////////////////////////////////////////////////\n/// STRING PARSING\n////////////////////////////////////////////////////////\n\n// parse a JSON string value, handling escape sequences and validating UTF-8\n// Returns the created string and the number of characters consumed.\n// Note that the number of characters consumed includes the surrounding quotes.\n// The number of bytes written to out differs from the number of characters\n// consumed in general because of escape sequences and UTF-8 encoding.\n[[nodiscard]] consteval std::pair<std::string, size_t>\nparse_string(std::string_view json) {\n auto cursor = json.begin();\n auto end = json.end();\n std::string out;\n\n // Expect starting quote\n if (cursor == end || *(cursor++) != '\"') {\n simdjson_consteval_error(\"Expected opening quote for string\");\n }\n // Notice that the quote is not appended.\n\n // Process \\uXXXX escape sequences, writes out to out.\n // Returns true on success, false on error.\n auto process_escaped_unicode = [&] [[nodiscard]] () -> bool {\n // Processing \\uXXXX escape sequence is a bit complicated, so we\n // define helper lambdas here.\n //\n // consume the XXXX in \\uXXXX and return the corresponding code point.\n // In case of error, a value greater than 0xFFFF is returned.\n // The caller should check!\n auto hex_to_u32 = [&] [[nodiscard]] () -> uint32_t {\n auto digit = [](uint8_t c) -> uint32_t {\n if (c >= '0' && c <= '9')\n return c - '0';\n if (c >= 'A' && c <= 'F')\n return c - 'A' + 10;\n if (c >= 'a' && c <= 'f')\n return c - 'a' + 10;\n return 0xFFFFFFFF;\n };\n if (end - cursor < 4) {\n return 0xFFFFFFFF;\n }\n uint32_t d0 = digit(*cursor++);\n uint32_t d1 = digit(*cursor++);\n uint32_t d2 = digit(*cursor++);\n uint32_t d3 = digit(*cursor++);\n\n return (d0 << 12) | (d1 << 8) | (d2 << 4) | d3;\n };\n // Write code point as UTF-8 into out.\n // The caller must ensure that the code point is valid,\n // i.e., not in the surrogate range or greater than 0x10FFFF.\n auto codepoint_to_utf8 = [&out] [[nodiscard]] (uint32_t cp) -> bool {\n // the high and low surrogates U+D800 through U+DFFF are invalid code\n // points\n if (cp > 0x10FFFF || (cp >= 0xD800 && cp <= 0xDFFF)) {\n return false;\n }\n if (cp <= 0x7F) {\n out.push_back(uint8_t(cp));\n } else if (cp <= 0x7FF) {\n out.push_back(uint8_t((cp >> 6) + 192));\n out.push_back(uint8_t((cp & 63) + 128));\n } else if (cp <= 0xFFFF) {\n out.push_back(uint8_t((cp >> 12) + 224));\n out.push_back(uint8_t(((cp >> 6) & 63) + 128));\n out.push_back(uint8_t((cp & 63) + 128));\n } else if (cp <= 0x10FFFF) {\n out.push_back(uint8_t((cp >> 18) + 240));\n out.push_back(uint8_t(((cp >> 12) & 63) + 128));\n out.push_back(uint8_t(((cp >> 6) & 63) + 128));\n out.push_back(uint8_t((cp & 63) + 128));\n } else {\n return false;\n }\n return true;\n };\n // We begin the implementation of process_escaped_unicode here.\n // The substitution_code_point is used for invalid sequences.\n // (This is U+FFFD, the Unicode replacement character.)\n constexpr uint32_t substitution_code_point = 0xfffd;\n // We need at least 4 characters for the hex digits\n if (end - cursor < 4) {\n return false;\n }\n // Consume the 4 hex digits\n uint32_t code_point = hex_to_u32();\n // Check for validity\n if (code_point > 0xFFFF) {\n return false;\n }\n // If we have a high surrogate, we need to process a low surrogate\n if (code_point >= 0xd800 && code_point < 0xdc00) {\n // We need at least 6 more characters for \\uXXXX, if they are NOT\n // present, we have an error (isolated high surrogate), which we\n // tolerate by substituting the substitution_code_point.\n if (end - cursor < 6 || *cursor != '\\\\' ||\n *(cursor + 1) != 'u' > 0xFFFF) {\n code_point = substitution_code_point;\n } else { // we have \\u following the high surrogate\n cursor += 2; // skip \\u\n uint32_t code_point_2 = hex_to_u32();\n if (code_point_2 > 0xFFFF) {\n return false;\n }\n uint32_t low_bit = code_point_2 - 0xdc00;\n if (low_bit >> 10) {\n // Not a valid low surrogate\n code_point = substitution_code_point;\n } else {\n code_point = ((code_point - 0xd800) << 10 | low_bit) + 0x10000;\n }\n }\n } else if (code_point >= 0xdc00 && code_point < 0xe000) {\n // Isolated low surrogate, invalid\n code_point = substitution_code_point;\n }\n // Now we have the final code point, write it as UTF-8 to out.\n return codepoint_to_utf8(code_point);\n };\n\n while (cursor != end && *cursor != '\"') {\n // If we find the end of input before closing quote, it's an error\n if (cursor == end) {\n simdjson_consteval_error(\"Unterminated string\");\n }\n // capture the next character and move forward\n char c = *(cursor++);\n // The one case where we don't want to append to the string directly\n // is when the string contains escape sequences.\n\n if (c == '\\\\') {\n // Assume that it is the start of an escape sequence\n size_t how_many_backslashes = 1;\n while (cursor != end && *(cursor) == '\\\\') {\n cursor++;\n how_many_backslashes++;\n }\n size_t backslashes_to_add = how_many_backslashes / 2;\n // Append the backslashes\n for (size_t i = 0; i < backslashes_to_add; i++) {\n out += '\\\\';\n }\n // If we have an odd number of backslashes, we have an escape sequence\n // besides the backslashes we have already added.\n if (how_many_backslashes % 2 == 1) {\n // If we have an odd number of backslashes, we must be in an escape\n // sequence check that what follows is a valid escape character\n if (cursor == end) {\n simdjson_consteval_error(\"Truncated escape sequence in string\");\n }\n char next_char = *cursor;\n cursor++;\n switch (next_char) {\n case '\"':\n out += '\"';\n break;\n case '/':\n out += '/';\n break;\n case 'b':\n out += '\\b';\n break;\n case 'f':\n out += '\\f';\n break;\n case 'n':\n out += '\\n';\n break;\n case 'r':\n out += '\\r';\n break;\n case 't':\n out += '\\t';\n break;\n case 'u':\n if (!process_escaped_unicode()) {\n simdjson_consteval_error(\n \"Invalid unicode escape sequence in string\");\n }\n break;\n default:\n simdjson_consteval_error(\"Invalid escape character in string\");\n }\n }\n continue; // continue to next iteration\n }\n // Handle escape sequences and UTF-8 validation. We do not process\n // the escape sequences here, just validate them.\n out += c;\n if (static_cast<unsigned char>(c) < 0x20) {\n simdjson_consteval_error(\"Invalid control character in string\");\n }\n if (static_cast<unsigned char>(c) >= 0x80) {\n // We have a non-ASCII character inside a string\n // We must validate it.\n uint8_t first_byte = static_cast<uint8_t>(c);\n\n if ((first_byte & 0b11100000) == 0b11000000) {\n if (cursor == end) {\n simdjson_consteval_error(\"Truncated UTF-8 sequence in string\");\n }\n\n char second_byte = *cursor;\n out += second_byte;\n ++cursor;\n if ((static_cast<uint8_t>(second_byte) & 0b11000000) != 0b10000000) {\n simdjson_consteval_error(\"Invalid UTF-8 continuation byte in string\");\n }\n // range check\n uint32_t code_point = (first_byte & 0b00011111) << 6 |\n (static_cast<uint8_t>(second_byte) & 0b00111111);\n if ((code_point < 0x80) || (0x7ff < code_point)) {\n simdjson_consteval_error(\"Invalid UTF-8 code point in string\");\n }\n } else if ((first_byte & 0b11110000) == 0b11100000) {\n if (cursor == end) {\n simdjson_consteval_error(\"Truncated UTF-8 sequence in string\");\n }\n char second_byte = *cursor;\n ++cursor;\n out += second_byte;\n if ((static_cast<uint8_t>(second_byte) & 0b11000000) != 0b10000000) {\n simdjson_consteval_error(\"Invalid UTF-8 continuation byte in string\");\n }\n if (cursor == end) {\n simdjson_consteval_error(\"Truncated UTF-8 sequence in string\");\n }\n char third_byte = *cursor;\n ++cursor;\n out += third_byte;\n if ((static_cast<uint8_t>(third_byte) & 0b11000000) != 0b10000000) {\n simdjson_consteval_error(\"Invalid UTF-8 continuation byte in string\");\n }\n // range check\n uint32_t code_point = (first_byte & 0b00001111) << 12 |\n (static_cast<uint8_t>(second_byte) & 0b00111111)\n << 6 |\n (static_cast<uint8_t>(third_byte) & 0b00111111);\n if ((code_point < 0x800) || (0xffff < code_point) ||\n (0xd7ff < code_point && code_point < 0xe000)) {\n simdjson_consteval_error(\"Invalid UTF-8 code point in string\");\n }\n } else if ((first_byte & 0b11111000) == 0b11110000) { // 0b11110000\n if (cursor == end) {\n simdjson_consteval_error(\"Truncated UTF-8 sequence in string\");\n }\n char second_byte = *cursor;\n ++cursor;\n out += second_byte;\n if (cursor == end) {\n simdjson_consteval_error(\"Truncated UTF-8 sequence in string\");\n }\n char third_byte = *cursor;\n ++cursor;\n out += third_byte;\n if (cursor == end) {\n simdjson_consteval_error(\"Truncated UTF-8 sequence in string\");\n }\n char fourth_byte = *cursor;\n ++cursor;\n out += fourth_byte;\n if ((static_cast<uint8_t>(second_byte) & 0b11000000) != 0b10000000) {\n simdjson_consteval_error(\"Invalid UTF-8 continuation byte in string\");\n }\n if ((static_cast<uint8_t>(third_byte) & 0b11000000) != 0b10000000) {\n simdjson_consteval_error(\"Invalid UTF-8 continuation byte in string\");\n }\n if ((static_cast<uint8_t>(fourth_byte) & 0b11000000) != 0b10000000) {\n simdjson_consteval_error(\"Invalid UTF-8 continuation byte in string\");\n }\n // range check\n uint32_t code_point =\n (first_byte & 0b00000111) << 18 |\n (static_cast<uint8_t>(second_byte) & 0b00111111) << 12 |\n (static_cast<uint8_t>(third_byte) & 0b00111111) << 6 |\n (static_cast<uint8_t>(fourth_byte) & 0b00111111);\n if (code_point <= 0xffff || 0x10ffff < code_point) {\n simdjson_consteval_error(\"Invalid UTF-8 code point in string\");\n }\n } else {\n // we have a continuation\n simdjson_consteval_error(\"Invalid UTF-8 continuation byte in string\");\n }\n continue;\n }\n }\n if (cursor == end) {\n simdjson_consteval_error(\"Unterminated string\");\n }\n if (*cursor != '\"') {\n simdjson_consteval_error(\"Internal error: expected closing quote\");\n }\n cursor++; // consume the closing quote\n // We get here if and only if we have seen the closing quote.\n\n return {out, size_t(cursor - json.begin())};\n}\n\n////////////////////////////////////////////////////\n/// ARRAY PARSING\n////////////////////////////////////////////////////\n\n// Parses a JSON array and returns a std::meta::info representing the array as\n// well as the number of characters consumed.\nconsteval std::pair<std::meta::info, size_t>\nparse_json_array_impl(const std::string_view json) {\n size_t consumed = 0;\n auto cursor = json.begin();\n auto end = json.end();\n auto is_whitespace = [](char c) {\n return c == ' ' || c == '\\n' || c == '\\t' || c == '\\r';\n };\n\n auto skip_whitespace = [&]() -> void {\n while (cursor != end && is_whitespace(*cursor))\n cursor++;\n };\n\n auto expect_consume = [&] [[nodiscard]] (char c) -> bool {\n skip_whitespace();\n if (cursor == end || *(cursor++) != c) {\n return false;\n };\n return true;\n };\n\n if (!expect_consume('[')) {\n simdjson_consteval_error(\"Expected '['\");\n }\n\n std::vector<std::meta::info> values = {^^void};\n skip_whitespace();\n if (cursor != end && *cursor == ']') {\n if (!expect_consume(']')) {\n simdjson_consteval_error(\"Expected ']'\");\n }\n // Empty array - use int as placeholder type since void doesn't work\n auto array_type = std::meta::substitute(\n ^^std::array, {\n ^^int, std::meta::reflect_constant(0uz)});\n values[0] = array_type;\n consumed = size_t(cursor - json.begin());\n if (json[consumed - 1] != ']') {\n simdjson_consteval_error(\"Expected ']'\");\n }\n return {std::meta::substitute(^^construct_from, values), consumed};\n }\n while (cursor != end && *cursor != ']') {\n char c = *cursor;\n switch (c) {\n case '{': {\n std::string_view value(cursor, end);\n auto [parsed, object_size] = parse_json_object_impl(value);\n if (*(cursor + object_size - 1) != '}') {\n simdjson_consteval_error(\"Expected '}'\");\n }\n values.push_back(parsed);\n cursor += object_size;\n break;\n }\n case '[': {\n std::string_view value(cursor, end);\n auto [parsed, array_size] = parse_json_array_impl(value);\n if (*(cursor + array_size - 1) != ']') {\n simdjson_consteval_error(\"Expected ']'\");\n }\n values.push_back(parsed);\n cursor += array_size;\n break;\n }\n case '\"': {\n auto res = parse_string(std::string_view(cursor, end));\n cursor += res.second;\n for (char ch : res.first) {\n if (ch == '\\0') {\n simdjson_consteval_error(\n \"Field string values cannot contain embedded nulls\");\n }\n }\n values.push_back(std::meta::reflect_constant_string(res.first));\n break;\n }\n case 't': {\n if (end - cursor < 4 || std::string_view(cursor, 4) != \"true\") {\n simdjson_consteval_error(\"Invalid value\");\n }\n cursor += 4;\n values.push_back(std::meta::reflect_constant(true));\n break;\n }\n case 'f': {\n if (end - cursor < 5 || std::string_view(cursor, 5) != \"false\") {\n simdjson_consteval_error(\"Invalid value\");\n }\n cursor += 5;\n values.push_back(std::meta::reflect_constant(false));\n break;\n }\n case 'n': {\n if (end - cursor < 4 || std::string_view(cursor, 4) != \"null\") {\n simdjson_consteval_error(\"Invalid value\");\n }\n cursor += 4;\n values.push_back(std::meta::reflect_constant(nullptr));\n break;\n }\n // We deliberately do not include '+' here, as per JSON spec\n case '-':\n case '0':\n case '1':\n case '2':\n case '3':\n case '4':\n case '5':\n case '6':\n case '7':\n case '8':\n case '9': {\n std::string_view suffix = std::string_view(cursor, end);\n std::variant<int64_t, uint64_t, double> out;\n size_t r = parse_number(suffix, out);\n cursor += r;\n if (std::holds_alternative<int64_t>(out)) {\n int64_t int_value = std::get<int64_t>(out);\n values.push_back(std::meta::reflect_constant(int_value));\n } else if (std::holds_alternative<uint64_t>(out)) {\n uint64_t uint_value = std::get<uint64_t>(out);\n values.push_back(std::meta::reflect_constant(uint_value));\n } else {\n double float_value = std::get<double>(out);\n values.push_back(std::meta::reflect_constant(float_value));\n }\n break;\n }\n default:\n simdjson_consteval_error(\"Invalid character starting value\");\n }\n skip_whitespace();\n if (cursor != end && *cursor == ',') {\n ++cursor;\n skip_whitespace();\n }\n }\n\n if (!expect_consume(']')) {\n simdjson_consteval_error(\"Expected ']'\");\n }\n std::size_t count = values.size() - 1;\n // We assume all elements have the same type as the first element.\n // However, if the array is heterogeneous, we should use std::variant.\n auto array_type = std::meta::substitute(\n ^^std::array,\n {\n std::meta::type_of(values[1]), std::meta::reflect_constant(count)});\n\n // Create array instance with values\n values[0] = array_type;\n consumed = size_t(cursor - json.begin());\n if (json[consumed - 1] != ']') {\n simdjson_consteval_error(\"Expected ']'\");\n }\n return {std::meta::substitute(^^construct_from, values), consumed};\n}\n\n////////////////////////////////////////////////////\n/// OBJECT PARSING\n////////////////////////////////////////////////////\n\n// Parses a JSON object and returns a std::meta::info representing the object\n// type as well as the number of characters consumed.\nconsteval std::pair<std::meta::info, size_t>\nparse_json_object_impl(std::string_view json) {\n size_t consumed = 0;\n auto cursor = json.begin();\n auto end = json.end();\n\n auto skip_whitespace = [&]() -> void {\n while (cursor != end && is_whitespace(*cursor))\n cursor++;\n };\n\n auto expect_consume = [&] [[nodiscard]] (char c) -> bool {\n skip_whitespace();\n if (cursor == end || *(cursor++) != c) {\n return false;\n };\n return true;\n };\n\n if (!expect_consume('{')) {\n simdjson_consteval_error(\"Expected '{'\");\n }\n\n std::vector<std::meta::info> members;\n std::vector<std::meta::info> values = {^^void};\n\n while (cursor != end && *cursor != '}') {\n skip_whitespace();\n // Not all strings can be identifiers, but in JSON field names can be any\n // string. Thus we may have a problem if the field name contains characters\n // not allowed in identifiers. Let the standard library handle that case.\n auto field = parse_string(std::string_view(cursor, end));\n std::string field_name = field.first;\n cursor += field.second;\n if (!expect_consume(':')) {\n simdjson_consteval_error(\"Expected ':'\");\n }\n skip_whitespace();\n if (cursor == end) {\n simdjson_consteval_error(\"Expected value after colon\");\n }\n char c = *cursor;\n switch (c) {\n case '{': {\n std::string_view value(cursor, end);\n auto [parsed, object_size] = parse_json_object_impl(value);\n if (*(cursor + object_size - 1) != '}') {\n simdjson_consteval_error(\"Expected '}'\");\n }\n cursor += object_size;\n auto dms = std::meta::data_member_spec(std::meta::type_of(parsed),\n {.name = field_name});\n members.push_back(std::meta::reflect_constant(dms));\n values.push_back(parsed);\n\n break;\n }\n case '[': {\n std::string_view value(cursor, end);\n auto [parsed, array_size] = parse_json_array_impl(value);\n auto dms = std::meta::data_member_spec(std::meta::type_of(parsed),\n {.name = field_name});\n members.push_back(std::meta::reflect_constant(dms));\n values.push_back(parsed);\n if (*(cursor + array_size - 1) != ']') {\n simdjson_consteval_error(\"Expected ']'\");\n }\n cursor += array_size;\n\n break;\n }\n case '\"': {\n auto res = parse_string(std::string_view(cursor, end));\n std::string_view value = res.first;\n cursor += res.second;\n for (char ch : value) {\n if (ch == '\\0') {\n simdjson_consteval_error(\n \"Field string values cannot contain embedded nulls\");\n }\n }\n auto dms =\n std::meta::data_member_spec(^^const char *, {\n .name = field_name});\n members.push_back(std::meta::reflect_constant(dms));\n values.push_back(std::meta::reflect_constant_string(value));\n break;\n }\n case 't': {\n if (end - cursor < 4 || std::string_view(cursor, 4) != \"true\") {\n simdjson_consteval_error(\"Invalid value\");\n }\n cursor += 4;\n\n auto dms = std::meta::data_member_spec(^^bool, {\n .name = field_name});\n members.push_back(std::meta::reflect_constant(dms));\n values.push_back(std::meta::reflect_constant(true));\n break;\n }\n case 'f': {\n if (end - cursor < 5 || std::string_view(cursor, 5) != \"false\") {\n simdjson_consteval_error(\"Invalid value\");\n }\n cursor += 5;\n\n auto dms = std::meta::data_member_spec(^^bool, {\n .name = field_name});\n members.push_back(std::meta::reflect_constant(dms));\n values.push_back(std::meta::reflect_constant(false));\n break;\n }\n case 'n': {\n if (end - cursor < 4 || std::string_view(cursor, 4) != \"null\") {\n simdjson_consteval_error(\"Invalid value\");\n }\n cursor += 4;\n\n auto dms = std::meta::data_member_spec(^^std::nullptr_t,\n {\n .name = field_name});\n members.push_back(std::meta::reflect_constant(dms));\n values.push_back(std::meta::reflect_constant(nullptr));\n break;\n }\n // We deliberately do not include '+' here, as per JSON spec\n case '-':\n case '0':\n case '1':\n case '2':\n case '3':\n case '4':\n case '5':\n case '6':\n case '7':\n case '8':\n case '9': {\n std::string_view suffix = std::string_view(cursor, end);\n std::variant<int64_t, uint64_t, double> out;\n size_t r = parse_number(suffix, out);\n cursor += r;\n if (std::holds_alternative<int64_t>(out)) {\n int64_t int_value = std::get<int64_t>(out);\n auto dms =\n std::meta::data_member_spec(^^int64_t, {\n .name = field_name});\n members.push_back(std::meta::reflect_constant(dms));\n values.push_back(std::meta::reflect_constant(int_value));\n } else if (std::holds_alternative<uint64_t>(out)) {\n uint64_t uint_value = std::get<uint64_t>(out);\n auto dms =\n std::meta::data_member_spec(^^uint64_t, {\n .name = field_name});\n members.push_back(std::meta::reflect_constant(dms));\n values.push_back(std::meta::reflect_constant(uint_value));\n } else {\n double float_value = std::get<double>(out);\n auto dms =\n std::meta::data_member_spec(^^double, {\n .name = field_name});\n members.push_back(std::meta::reflect_constant(dms));\n values.push_back(std::meta::reflect_constant(float_value));\n }\n break;\n }\n default:\n simdjson_consteval_error(\"Invalid character starting value\");\n }\n skip_whitespace();\n if (cursor == end) {\n simdjson_consteval_error(\"Expected '}' or ','\");\n }\n if (*cursor == ',') {\n ++cursor;\n skip_whitespace();\n } else if (*cursor != '}') {\n simdjson_consteval_error(\"Expected '}'\");\n }\n }\n\n if (!expect_consume('}')) {\n simdjson_consteval_error(\"Expected '}'\");\n }\n values[0] = std::meta::substitute(^^class_type, members);\n consumed = size_t(cursor - json.begin());\n if (json[consumed - 1] != '}') {\n simdjson_consteval_error(\"Expected '}'\");\n }\n return {std::meta::substitute(^^construct_from, values), consumed};\n}\n\n/**\n * Our public function to parse JSON at compile time.\n * @brief Compile-time JSON parser. This function parses the provided JSON\n * string at compile time and returns a custom struct type representing the JSON\n * object.\n */\ntemplate <constevalutil::fixed_string json_str> consteval auto parse_json() {\n constexpr std::string_view json = trim_whitespace(json_str.view());\n static_assert(!json.empty(), \"JSON string cannot be empty\");\n /*static_assert(json.front() != '{' && json.front() != '[',\n \"Only JSON objects and arrays are supported at the top level, this \"\n \"limitation will be lifted in the future.\");*/\n\n constexpr auto result = json.front() == '['\n ? parse_json_array_impl(json)\n : parse_json_object_impl(json);\n return [: result.first :];\n /*\n if(json.front() == '[') {\n return [:parse_json_array_impl(json).first:];\n } else if(json.front() == '{') {\n // return [:parse_json_object_impl(json).first:];\n }*/\n}\n\n} // namespace compile_time\n} // namespace simdjson\n\n#endif // SIMDJSON_STATIC_REFLECTION\n#endif // SIMDJSON_GENERIC_COMPILE_TIME_JSON_INL_H\n/* end file simdjson/compile_time_json-inl.h */\n\n#endif // SIMDJSON_H\n/* end file simdjson.h */\n"}}},{"rowIdx":22981,"cells":{"text":{"kind":"string","value":"/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb\n no warranty implied; use at your own risk\n\n Do this:\n #define STB_IMAGE_IMPLEMENTATION\n before you include this file in *one* C or C++ file to create the implementation.\n\n // i.e. it should look like this:\n #include ...\n #include ...\n #include ...\n #define STB_IMAGE_IMPLEMENTATION\n #include \"stb_image.h\"\n\n You can #define STBI_ASSERT(x) before the #include to avoid using assert.h.\n And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free\n\n\n QUICK NOTES:\n Primarily of interest to game developers and other people who can\n avoid problematic images and only need the trivial interface\n\n JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib)\n PNG 1/2/4/8/16-bit-per-channel\n\n TGA (not sure what subset, if a subset)\n BMP non-1bpp, non-RLE\n PSD (composited view only, no extra channels, 8/16 bit-per-channel)\n\n GIF (*comp always reports as 4-channel)\n HDR (radiance rgbE format)\n PIC (Softimage PIC)\n PNM (PPM and PGM binary only)\n\n Animated GIF still needs a proper API, but here's one way to do it:\n http://gist.github.com/urraka/685d9a6340b26b830d49\n\n - decode from memory or through FILE (define STBI_NO_STDIO to remove code)\n - decode from arbitrary I/O callbacks\n - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON)\n\n Full documentation under \"DOCUMENTATION\" below.\n\n\nLICENSE\n\n See end of file for license information.\n\nRECENT REVISION HISTORY:\n\n 2.30 (2024-05-31) avoid erroneous gcc warning\n 2.29 (2023-05-xx) optimizations\n 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff\n 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes\n 2.26 (2020-07-13) many minor fixes\n 2.25 (2020-02-02) fix warnings\n 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically\n 2.23 (2019-08-11) fix clang static analysis warning\n 2.22 (2019-03-04) gif fixes, fix warnings\n 2.21 (2019-02-25) fix typo in comment\n 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs\n 2.19 (2018-02-11) fix warning\n 2.18 (2018-01-30) fix warnings\n 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings\n 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes\n 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC\n 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs\n 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes\n 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes\n 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64\n RGB-format JPEG; remove white matting in PSD;\n allocate large structures on the stack;\n correct channel count for PNG & BMP\n 2.10 (2016-01-22) avoid warning introduced in 2.09\n 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED\n\n See end of file for full revision history.\n\n\n ============================ Contributors =========================\n\n Image formats Extensions, features\n Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info)\n Nicolas Schulz (hdr, psd) Martin \"SpartanJ\" Golini (stbi_info)\n Jonathan Dummer (tga) James \"moose2000\" Brown (iPhone PNG)\n Jean-Marc Lienher (gif) Ben \"Disch\" Wenger (io callbacks)\n Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG)\n Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip)\n Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD)\n github:urraka (animated gif) Junggon Kim (PNM comments)\n Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA)\n socks-the-fox (16-bit PNG)\n Jeremy Sawicki (handle all ImageNet JPGs)\n Optimizations & bugfixes Mikhail Morozov (1-bit BMP)\n Fabian \"ryg\" Giesen Anael Seghezzi (is-16-bit query)\n Arseny Kapoulkine Simon Breuss (16-bit PNM)\n John-Mark Allen\n Carmelo J Fdez-Aguera\n\n Bug & warning fixes\n Marc LeBlanc David Woo Guillaume George Martins Mozeiko\n Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski\n Phil Jordan Dave Moore Roy Eltham\n Hayaki Saito Nathan Reed Won Chun\n Luke Graham Johan Duparc Nick Verigakis the Horde3D community\n Thomas Ruf Ronny Chevalier github:rlyeh\n Janez Zemva John Bartholomew Michal Cichon github:romigrou\n Jonathan Blow Ken Hamada Tero Hanninen github:svdijk\n Eugene Golushkov Laurent Gomila Cort Stratton github:snagar\n Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex\n Cass Everitt Ryamond Barbiero github:grim210\n Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw\n Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus\n Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo\n Julian Raschke Gregory Mullen Christian Floisand github:darealshinji\n Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007\n Brad Weinberger Matvey Cherevko github:mosra\n Luca Sas Alexander Veselov Zack Middleton [reserved]\n Ryan C. Gordon [reserved] [reserved]\n DO NOT ADD YOUR NAME HERE\n\n Jacko Dirks\n\n To add your name to the credits, pick a random blank space in the middle and fill it.\n 80% of merge conflicts on stb PRs are due to people adding their name at the end\n of the credits.\n*/\n\n#ifndef STBI_INCLUDE_STB_IMAGE_H\n#define STBI_INCLUDE_STB_IMAGE_H\n\n// DOCUMENTATION\n//\n// Limitations:\n// - no 12-bit-per-channel JPEG\n// - no JPEGs with arithmetic coding\n// - GIF always returns *comp=4\n//\n// Basic usage (see HDR discussion below for HDR usage):\n// int x,y,n;\n// unsigned char *data = stbi_load(filename, &x, &y, &n, 0);\n// // ... process data if not NULL ...\n// // ... x = width, y = height, n = # 8-bit components per pixel ...\n// // ... replace '0' with '1'..'4' to force that many components per pixel\n// // ... but 'n' will always be the number that it would have been if you said 0\n// stbi_image_free(data);\n//\n// Standard parameters:\n// int *x -- outputs image width in pixels\n// int *y -- outputs image height in pixels\n// int *channels_in_file -- outputs # of image components in image file\n// int desired_channels -- if non-zero, # of image components requested in result\n//\n// The return value from an image loader is an 'unsigned char *' which points\n// to the pixel data, or NULL on an allocation failure or if the image is\n// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels,\n// with each pixel consisting of N interleaved 8-bit components; the first\n// pixel pointed to is top-left-most in the image. There is no padding between\n// image scanlines or between pixels, regardless of format. The number of\n// components N is 'desired_channels' if desired_channels is non-zero, or\n// *channels_in_file otherwise. If desired_channels is non-zero,\n// *channels_in_file has the number of components that _would_ have been\n// output otherwise. E.g. if you set desired_channels to 4, you will always\n// get RGBA output, but you can check *channels_in_file to see if it's trivially\n// opaque because e.g. there were only 3 channels in the source image.\n//\n// An output image with N components has the following components interleaved\n// in this order in each pixel:\n//\n// N=#comp components\n// 1 grey\n// 2 grey, alpha\n// 3 red, green, blue\n// 4 red, green, blue, alpha\n//\n// If image loading fails for any reason, the return value will be NULL,\n// and *x, *y, *channels_in_file will be unchanged. The function\n// stbi_failure_reason() can be queried for an extremely brief, end-user\n// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS\n// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly\n// more user-friendly ones.\n//\n// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.\n//\n// To query the width, height and component count of an image without having to\n// decode the full file, you can use the stbi_info family of functions:\n//\n// int x,y,n,ok;\n// ok = stbi_info(filename, &x, &y, &n);\n// // returns ok=1 and sets x, y, n if image is a supported format,\n// // 0 otherwise.\n//\n// Note that stb_image pervasively uses ints in its public API for sizes,\n// including sizes of memory buffers. This is now part of the API and thus\n// hard to change without causing breakage. As a result, the various image\n// loaders all have certain limits on image size; these differ somewhat\n// by format but generally boil down to either just under 2GB or just under\n// 1GB. When the decoded image would be larger than this, stb_image decoding\n// will fail.\n//\n// Additionally, stb_image will reject image files that have any of their\n// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS,\n// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit,\n// the only way to have an image with such dimensions load correctly\n// is for it to have a rather extreme aspect ratio. Either way, the\n// assumption here is that such larger images are likely to be malformed\n// or malicious. If you do need to load an image with individual dimensions\n// larger than that, and it still fits in the overall size limit, you can\n// #define STBI_MAX_DIMENSIONS on your own to be something larger.\n//\n// ===========================================================================\n//\n// UNICODE:\n//\n// If compiling for Windows and you wish to use Unicode filenames, compile\n// with\n// #define STBI_WINDOWS_UTF8\n// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert\n// Windows wchar_t filenames to utf8.\n//\n// ===========================================================================\n//\n// Philosophy\n//\n// stb libraries are designed with the following priorities:\n//\n// 1. easy to use\n// 2. easy to maintain\n// 3. good performance\n//\n// Sometimes I let \"good performance\" creep up in priority over \"easy to maintain\",\n// and for best performance I may provide less-easy-to-use APIs that give higher\n// performance, in addition to the easy-to-use ones. Nevertheless, it's important\n// to keep in mind that from the standpoint of you, a client of this library,\n// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all.\n//\n// Some secondary priorities arise directly from the first two, some of which\n// provide more explicit reasons why performance can't be emphasized.\n//\n// - Portable (\"ease of use\")\n// - Small source code footprint (\"easy to maintain\")\n// - No dependencies (\"ease of use\")\n//\n// ===========================================================================\n//\n// I/O callbacks\n//\n// I/O callbacks allow you to read from arbitrary sources, like packaged\n// files or some other source. Data read from callbacks are processed\n// through a small internal buffer (currently 128 bytes) to try to reduce\n// overhead.\n//\n// The three functions you must define are \"read\" (reads some bytes of data),\n// \"skip\" (skips some bytes of data), \"eof\" (reports if the stream is at the end).\n//\n// ===========================================================================\n//\n// SIMD support\n//\n// The JPEG decoder will try to automatically use SIMD kernels on x86 when\n// supported by the compiler. For ARM Neon support, you must explicitly\n// request it.\n//\n// (The old do-it-yourself SIMD API is no longer supported in the current\n// code.)\n//\n// On x86, SSE2 will automatically be used when available based on a run-time\n// test; if not, the generic C versions are used as a fall-back. On ARM targets,\n// the typical path is to have separate builds for NEON and non-NEON devices\n// (at least this is true for iOS and Android). Therefore, the NEON support is\n// toggled by a build flag: define STBI_NEON to get NEON loops.\n//\n// If for some reason you do not want to use any of SIMD code, or if\n// you have issues compiling it, you can disable it entirely by\n// defining STBI_NO_SIMD.\n//\n// ===========================================================================\n//\n// HDR image support (disable by defining STBI_NO_HDR)\n//\n// stb_image supports loading HDR images in general, and currently the Radiance\n// .HDR file format specifically. You can still load any file through the existing\n// interface; if you attempt to load an HDR file, it will be automatically remapped\n// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;\n// both of these constants can be reconfigured through this interface:\n//\n// stbi_hdr_to_ldr_gamma(2.2f);\n// stbi_hdr_to_ldr_scale(1.0f);\n//\n// (note, do not use _inverse_ constants; stbi_image will invert them\n// appropriately).\n//\n// Additionally, there is a new, parallel interface for loading files as\n// (linear) floats to preserve the full dynamic range:\n//\n// float *data = stbi_loadf(filename, &x, &y, &n, 0);\n//\n// If you load LDR images through this interface, those images will\n// be promoted to floating point values, run through the inverse of\n// constants corresponding to the above:\n//\n// stbi_ldr_to_hdr_scale(1.0f);\n// stbi_ldr_to_hdr_gamma(2.2f);\n//\n// Finally, given a filename (or an open file or memory block--see header\n// file for details) containing image data, you can query for the \"most\n// appropriate\" interface to use (that is, whether the image is HDR or\n// not), using:\n//\n// stbi_is_hdr(char *filename);\n//\n// ===========================================================================\n//\n// iPhone PNG support:\n//\n// We optionally support converting iPhone-formatted PNGs (which store\n// premultiplied BGRA) back to RGB, even though they're internally encoded\n// differently. To enable this conversion, call\n// stbi_convert_iphone_png_to_rgb(1).\n//\n// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per\n// pixel to remove any premultiplied alpha *only* if the image file explicitly\n// says there's premultiplied data (currently only happens in iPhone images,\n// and only if iPhone convert-to-rgb processing is on).\n//\n// ===========================================================================\n//\n// ADDITIONAL CONFIGURATION\n//\n// - You can suppress implementation of any of the decoders to reduce\n// your code footprint by #defining one or more of the following\n// symbols before creating the implementation.\n//\n// STBI_NO_JPEG\n// STBI_NO_PNG\n// STBI_NO_BMP\n// STBI_NO_PSD\n// STBI_NO_TGA\n// STBI_NO_GIF\n// STBI_NO_HDR\n// STBI_NO_PIC\n// STBI_NO_PNM (.ppm and .pgm)\n//\n// - You can request *only* certain decoders and suppress all other ones\n// (this will be more forward-compatible, as addition of new decoders\n// doesn't require you to disable them explicitly):\n//\n// STBI_ONLY_JPEG\n// STBI_ONLY_PNG\n// STBI_ONLY_BMP\n// STBI_ONLY_PSD\n// STBI_ONLY_TGA\n// STBI_ONLY_GIF\n// STBI_ONLY_HDR\n// STBI_ONLY_PIC\n// STBI_ONLY_PNM (.ppm and .pgm)\n//\n// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still\n// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB\n//\n// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater\n// than that size (in either width or height) without further processing.\n// This is to let programs in the wild set an upper bound to prevent\n// denial-of-service attacks on untrusted data, as one could generate a\n// valid image of gigantic dimensions and force stb_image to allocate a\n// huge block of memory and spend disproportionate time decoding it. By\n// default this is set to (1 << 24), which is 16777216, but that's still\n// very big.\n\n#ifndef STBI_NO_STDIO\n#include <stdio.h>\n#endif // STBI_NO_STDIO\n\n#define STBI_VERSION 1\n\nenum\n{\n STBI_default = 0, // only used for desired_channels\n\n STBI_grey = 1,\n STBI_grey_alpha = 2,\n STBI_rgb = 3,\n STBI_rgb_alpha = 4\n};\n\n#include <stdlib.h>\ntypedef unsigned char stbi_uc;\ntypedef unsigned short stbi_us;\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#ifndef STBIDEF\n#ifdef STB_IMAGE_STATIC\n#define STBIDEF static\n#else\n#define STBIDEF extern\n#endif\n#endif\n\n//////////////////////////////////////////////////////////////////////////////\n//\n// PRIMARY API - works on images of any type\n//\n\n//\n// load image by filename, open file, or memory buffer\n//\n\ntypedef struct\n{\n int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read\n void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative\n int (*eof) (void *user); // returns nonzero if we are at end of file/data\n} stbi_io_callbacks;\n\n////////////////////////////////////\n//\n// 8-bits-per-channel interface\n//\n\nSTBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels);\nSTBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels);\n\n#ifndef STBI_NO_STDIO\nSTBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);\nSTBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);\n// for stbi_load_from_file, file pointer is left pointing immediately after image\n#endif\n\n#ifndef STBI_NO_GIF\nSTBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp);\n#endif\n\n#ifdef STBI_WINDOWS_UTF8\nSTBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);\n#endif\n\n////////////////////////////////////\n//\n// 16-bits-per-channel interface\n//\n\nSTBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);\nSTBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);\n\n#ifndef STBI_NO_STDIO\nSTBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);\nSTBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);\n#endif\n\n////////////////////////////////////\n//\n// float-per-channel interface\n//\n#ifndef STBI_NO_LINEAR\n STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels);\n STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels);\n\n #ifndef STBI_NO_STDIO\n STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels);\n STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels);\n #endif\n#endif\n\n#ifndef STBI_NO_HDR\n STBIDEF void stbi_hdr_to_ldr_gamma(float gamma);\n STBIDEF void stbi_hdr_to_ldr_scale(float scale);\n#endif // STBI_NO_HDR\n\n#ifndef STBI_NO_LINEAR\n STBIDEF void stbi_ldr_to_hdr_gamma(float gamma);\n STBIDEF void stbi_ldr_to_hdr_scale(float scale);\n#endif // STBI_NO_LINEAR\n\n// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR\nSTBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);\nSTBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);\n#ifndef STBI_NO_STDIO\nSTBIDEF int stbi_is_hdr (char const *filename);\nSTBIDEF int stbi_is_hdr_from_file(FILE *f);\n#endif // STBI_NO_STDIO\n\n\n// get a VERY brief reason for failure\n// on most compilers (and ALL modern mainstream compilers) this is threadsafe\nSTBIDEF const char *stbi_failure_reason (void);\n\n// free the loaded image -- this is just free()\nSTBIDEF void stbi_image_free (void *retval_from_stbi_load);\n\n// get image dimensions & components without fully decoding\nSTBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);\nSTBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);\nSTBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len);\nSTBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user);\n\n#ifndef STBI_NO_STDIO\nSTBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp);\nSTBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp);\nSTBIDEF int stbi_is_16_bit (char const *filename);\nSTBIDEF int stbi_is_16_bit_from_file(FILE *f);\n#endif\n\n\n\n// for image formats that explicitly notate that they have premultiplied alpha,\n// we just return the colors as stored in the file. set this flag to force\n// unpremultiplication. results are undefined if the unpremultiply overflow.\nSTBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);\n\n// indicate whether we should process iphone images back to canonical format,\n// or just pass them through \"as-is\"\nSTBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);\n\n// flip the image vertically, so the first pixel in the output array is the bottom left\nSTBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip);\n\n// as above, but only applies to images loaded on the thread that calls the function\n// this function is only available if your compiler supports thread-local variables;\n// calling it will fail to link if your compiler doesn't\nSTBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply);\nSTBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert);\nSTBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip);\n\n// ZLIB client - used by PNG, available for other purposes\n\nSTBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);\nSTBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);\nSTBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);\nSTBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);\n\nSTBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);\nSTBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);\n\n\n#ifdef __cplusplus\n}\n#endif\n\n//\n//\n//// end header file /////////////////////////////////////////////////////\n#endif // STBI_INCLUDE_STB_IMAGE_H\n\n#ifdef STB_IMAGE_IMPLEMENTATION\n\n#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \\\n || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \\\n || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \\\n || defined(STBI_ONLY_ZLIB)\n #ifndef STBI_ONLY_JPEG\n #define STBI_NO_JPEG\n #endif\n #ifndef STBI_ONLY_PNG\n #define STBI_NO_PNG\n #endif\n #ifndef STBI_ONLY_BMP\n #define STBI_NO_BMP\n #endif\n #ifndef STBI_ONLY_PSD\n #define STBI_NO_PSD\n #endif\n #ifndef STBI_ONLY_TGA\n #define STBI_NO_TGA\n #endif\n #ifndef STBI_ONLY_GIF\n #define STBI_NO_GIF\n #endif\n #ifndef STBI_ONLY_HDR\n #define STBI_NO_HDR\n #endif\n #ifndef STBI_ONLY_PIC\n #define STBI_NO_PIC\n #endif\n #ifndef STBI_ONLY_PNM\n #define STBI_NO_PNM\n #endif\n#endif\n\n#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB)\n#define STBI_NO_ZLIB\n#endif\n\n\n#include <stdarg.h>\n#include <stddef.h> // ptrdiff_t on osx\n#include <stdlib.h>\n#include <string.h>\n#include <limits.h>\n\n#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR)\n#include <math.h> // ldexp, pow\n#endif\n\n#ifndef STBI_NO_STDIO\n#include <stdio.h>\n#endif\n\n#ifndef STBI_ASSERT\n#include <assert.h>\n#define STBI_ASSERT(x) assert(x)\n#endif\n\n#ifdef __cplusplus\n#define STBI_EXTERN extern \"C\"\n#else\n#define STBI_EXTERN extern\n#endif\n\n\n#ifndef _MSC_VER\n #ifdef __cplusplus\n #define stbi_inline inline\n #else\n #define stbi_inline\n #endif\n#else\n #define stbi_inline __forceinline\n#endif\n\n#ifndef STBI_NO_THREAD_LOCALS\n #if defined(__cplusplus) && __cplusplus >= 201103L\n #define STBI_THREAD_LOCAL thread_local\n #elif defined(__GNUC__) && __GNUC__ < 5\n #define STBI_THREAD_LOCAL __thread\n #elif defined(_MSC_VER)\n #define STBI_THREAD_LOCAL __declspec(thread)\n #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)\n #define STBI_THREAD_LOCAL _Thread_local\n #endif\n\n #ifndef STBI_THREAD_LOCAL\n #if defined(__GNUC__)\n #define STBI_THREAD_LOCAL __thread\n #endif\n #endif\n#endif\n\n#if defined(_MSC_VER) || defined(__SYMBIAN32__)\ntypedef unsigned short stbi__uint16;\ntypedef signed short stbi__int16;\ntypedef unsigned int stbi__uint32;\ntypedef signed int stbi__int32;\n#else\n#include <stdint.h>\ntypedef uint16_t stbi__uint16;\ntypedef int16_t stbi__int16;\ntypedef uint32_t stbi__uint32;\ntypedef int32_t stbi__int32;\n#endif\n\n// should produce compiler error if size is wrong\ntypedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1];\n\n#ifdef _MSC_VER\n#define STBI_NOTUSED(v) (void)(v)\n#else\n#define STBI_NOTUSED(v) (void)sizeof(v)\n#endif\n\n#ifdef _MSC_VER\n#define STBI_HAS_LROTL\n#endif\n\n#ifdef STBI_HAS_LROTL\n #define stbi_lrot(x,y) _lrotl(x,y)\n#else\n #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31)))\n#endif\n\n#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED))\n// ok\n#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED)\n// ok\n#else\n#error \"Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED).\"\n#endif\n\n#ifndef STBI_MALLOC\n#define STBI_MALLOC(sz) malloc(sz)\n#define STBI_REALLOC(p,newsz) realloc(p,newsz)\n#define STBI_FREE(p) free(p)\n#endif\n\n#ifndef STBI_REALLOC_SIZED\n#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz)\n#endif\n\n// x86/x64 detection\n#if defined(__x86_64__) || defined(_M_X64)\n#define STBI__X64_TARGET\n#elif defined(__i386) || defined(_M_IX86)\n#define STBI__X86_TARGET\n#endif\n\n#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD)\n// gcc doesn't support sse2 intrinsics unless you compile with -msse2,\n// which in turn means it gets to use SSE2 everywhere. This is unfortunate,\n// but previous attempts to provide the SSE2 functions with runtime\n// detection caused numerous issues. The way architecture extensions are\n// exposed in GCC/Clang is, sadly, not really suited for one-file libs.\n// New behavior: if compiled with -msse2, we use SSE2 without any\n// detection; if not, we don't use it at all.\n#define STBI_NO_SIMD\n#endif\n\n#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD)\n// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET\n//\n// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the\n// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant.\n// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not\n// simultaneously enabling \"-mstackrealign\".\n//\n// See https://github.com/nothings/stb/issues/81 for more information.\n//\n// So default to no SSE2 on 32-bit MinGW. If you've read this far and added\n// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2.\n#define STBI_NO_SIMD\n#endif\n\n#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET))\n#define STBI_SSE2\n#include <emmintrin.h>\n\n#ifdef _MSC_VER\n\n#if _MSC_VER >= 1400 // not VC6\n#include <intrin.h> // __cpuid\nstatic int stbi__cpuid3(void)\n{\n int info[4];\n __cpuid(info,1);\n return info[3];\n}\n#else\nstatic int stbi__cpuid3(void)\n{\n int res;\n __asm {\n mov eax,1\n cpuid\n mov res,edx\n }\n return res;\n}\n#endif\n\n#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name\n\n#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)\nstatic int stbi__sse2_available(void)\n{\n int info3 = stbi__cpuid3();\n return ((info3 >> 26) & 1) != 0;\n}\n#endif\n\n#else // assume GCC-style if not VC++\n#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))\n\n#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2)\nstatic int stbi__sse2_available(void)\n{\n // If we're even attempting to compile this on GCC/Clang, that means\n // -msse2 is on, which means the compiler is allowed to use SSE2\n // instructions at will, and so are we.\n return 1;\n}\n#endif\n\n#endif\n#endif\n\n// ARM NEON\n#if defined(STBI_NO_SIMD) && defined(STBI_NEON)\n#undef STBI_NEON\n#endif\n\n#ifdef STBI_NEON\n#include <arm_neon.h>\n#ifdef _MSC_VER\n#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name\n#else\n#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16)))\n#endif\n#endif\n\n#ifndef STBI_SIMD_ALIGN\n#define STBI_SIMD_ALIGN(type, name) type name\n#endif\n\n#ifndef STBI_MAX_DIMENSIONS\n#define STBI_MAX_DIMENSIONS (1 << 24)\n#endif\n\n///////////////////////////////////////////////\n//\n// stbi__context struct and start_xxx functions\n\n// stbi__context structure is our basic context used by all images, so it\n// contains all the IO context, plus some basic image information\ntypedef struct\n{\n stbi__uint32 img_x, img_y;\n int img_n, img_out_n;\n\n stbi_io_callbacks io;\n void *io_user_data;\n\n int read_from_callbacks;\n int buflen;\n stbi_uc buffer_start[128];\n int callback_already_read;\n\n stbi_uc *img_buffer, *img_buffer_end;\n stbi_uc *img_buffer_original, *img_buffer_original_end;\n} stbi__context;\n\n\nstatic void stbi__refill_buffer(stbi__context *s);\n\n// initialize a memory-decode context\nstatic void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len)\n{\n s->io.read = NULL;\n s->read_from_callbacks = 0;\n s->callback_already_read = 0;\n s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer;\n s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len;\n}\n\n// initialize a callback-based context\nstatic void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user)\n{\n s->io = *c;\n s->io_user_data = user;\n s->buflen = sizeof(s->buffer_start);\n s->read_from_callbacks = 1;\n s->callback_already_read = 0;\n s->img_buffer = s->img_buffer_original = s->buffer_start;\n stbi__refill_buffer(s);\n s->img_buffer_original_end = s->img_buffer_end;\n}\n\n#ifndef STBI_NO_STDIO\n\nstatic int stbi__stdio_read(void *user, char *data, int size)\n{\n return (int) fread(data,1,size,(FILE*) user);\n}\n\nstatic void stbi__stdio_skip(void *user, int n)\n{\n int ch;\n fseek((FILE*) user, n, SEEK_CUR);\n ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */\n if (ch != EOF) {\n ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */\n }\n}\n\nstatic int stbi__stdio_eof(void *user)\n{\n return feof((FILE*) user) || ferror((FILE *) user);\n}\n\nstatic stbi_io_callbacks stbi__stdio_callbacks =\n{\n stbi__stdio_read,\n stbi__stdio_skip,\n stbi__stdio_eof,\n};\n\nstatic void stbi__start_file(stbi__context *s, FILE *f)\n{\n stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f);\n}\n\n//static void stop_file(stbi__context *s) { }\n\n#endif // !STBI_NO_STDIO\n\nstatic void stbi__rewind(stbi__context *s)\n{\n // conceptually rewind SHOULD rewind to the beginning of the stream,\n // but we just rewind to the beginning of the initial buffer, because\n // we only use it after doing 'test', which only ever looks at at most 92 bytes\n s->img_buffer = s->img_buffer_original;\n s->img_buffer_end = s->img_buffer_original_end;\n}\n\nenum\n{\n STBI_ORDER_RGB,\n STBI_ORDER_BGR\n};\n\ntypedef struct\n{\n int bits_per_channel;\n int num_channels;\n int channel_order;\n} stbi__result_info;\n\n#ifndef STBI_NO_JPEG\nstatic int stbi__jpeg_test(stbi__context *s);\nstatic void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);\nstatic int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp);\n#endif\n\n#ifndef STBI_NO_PNG\nstatic int stbi__png_test(stbi__context *s);\nstatic void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);\nstatic int stbi__png_info(stbi__context *s, int *x, int *y, int *comp);\nstatic int stbi__png_is16(stbi__context *s);\n#endif\n\n#ifndef STBI_NO_BMP\nstatic int stbi__bmp_test(stbi__context *s);\nstatic void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);\nstatic int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp);\n#endif\n\n#ifndef STBI_NO_TGA\nstatic int stbi__tga_test(stbi__context *s);\nstatic void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);\nstatic int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp);\n#endif\n\n#ifndef STBI_NO_PSD\nstatic int stbi__psd_test(stbi__context *s);\nstatic void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc);\nstatic int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp);\nstatic int stbi__psd_is16(stbi__context *s);\n#endif\n\n#ifndef STBI_NO_HDR\nstatic int stbi__hdr_test(stbi__context *s);\nstatic float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);\nstatic int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp);\n#endif\n\n#ifndef STBI_NO_PIC\nstatic int stbi__pic_test(stbi__context *s);\nstatic void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);\nstatic int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp);\n#endif\n\n#ifndef STBI_NO_GIF\nstatic int stbi__gif_test(stbi__context *s);\nstatic void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);\nstatic void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp);\nstatic int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp);\n#endif\n\n#ifndef STBI_NO_PNM\nstatic int stbi__pnm_test(stbi__context *s);\nstatic void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri);\nstatic int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp);\nstatic int stbi__pnm_is16(stbi__context *s);\n#endif\n\nstatic\n#ifdef STBI_THREAD_LOCAL\nSTBI_THREAD_LOCAL\n#endif\nconst char *stbi__g_failure_reason;\n\nSTBIDEF const char *stbi_failure_reason(void)\n{\n return stbi__g_failure_reason;\n}\n\n#ifndef STBI_NO_FAILURE_STRINGS\nstatic int stbi__err(const char *str)\n{\n stbi__g_failure_reason = str;\n return 0;\n}\n#endif\n\nstatic void *stbi__malloc(size_t size)\n{\n return STBI_MALLOC(size);\n}\n\n// stb_image uses ints pervasively, including for offset calculations.\n// therefore the largest decoded image size we can support with the\n// current code, even on 64-bit targets, is INT_MAX. this is not a\n// significant limitation for the intended use case.\n//\n// we do, however, need to make sure our size calculations don't\n// overflow. hence a few helper functions for size calculations that\n// multiply integers together, making sure that they're non-negative\n// and no overflow occurs.\n\n// return 1 if the sum is valid, 0 on overflow.\n// negative terms are considered invalid.\nstatic int stbi__addsizes_valid(int a, int b)\n{\n if (b < 0) return 0;\n // now 0 <= b <= INT_MAX, hence also\n // 0 <= INT_MAX - b <= INTMAX.\n // And \"a + b <= INT_MAX\" (which might overflow) is the\n // same as a <= INT_MAX - b (no overflow)\n return a <= INT_MAX - b;\n}\n\n// returns 1 if the product is valid, 0 on overflow.\n// negative factors are considered invalid.\nstatic int stbi__mul2sizes_valid(int a, int b)\n{\n if (a < 0 || b < 0) return 0;\n if (b == 0) return 1; // mul-by-0 is always safe\n // portable way to check for no overflows in a*b\n return a <= INT_MAX/b;\n}\n\n#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)\n// returns 1 if \"a*b + add\" has no negative terms/factors and doesn't overflow\nstatic int stbi__mad2sizes_valid(int a, int b, int add)\n{\n return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add);\n}\n#endif\n\n// returns 1 if \"a*b*c + add\" has no negative terms/factors and doesn't overflow\nstatic int stbi__mad3sizes_valid(int a, int b, int c, int add)\n{\n return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&\n stbi__addsizes_valid(a*b*c, add);\n}\n\n// returns 1 if \"a*b*c*d + add\" has no negative terms/factors and doesn't overflow\n#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)\nstatic int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)\n{\n return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&\n stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add);\n}\n#endif\n\n#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR)\n// mallocs with size overflow checking\nstatic void *stbi__malloc_mad2(int a, int b, int add)\n{\n if (!stbi__mad2sizes_valid(a, b, add)) return NULL;\n return stbi__malloc(a*b + add);\n}\n#endif\n\nstatic void *stbi__malloc_mad3(int a, int b, int c, int add)\n{\n if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL;\n return stbi__malloc(a*b*c + add);\n}\n\n#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM)\nstatic void *stbi__malloc_mad4(int a, int b, int c, int d, int add)\n{\n if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL;\n return stbi__malloc(a*b*c*d + add);\n}\n#endif\n\n// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow.\nstatic int stbi__addints_valid(int a, int b)\n{\n if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow\n if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0.\n return a <= INT_MAX - b;\n}\n\n// returns 1 if the product of two ints fits in a signed short, 0 on overflow.\nstatic int stbi__mul2shorts_valid(int a, int b)\n{\n if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow\n if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid\n if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN\n return a >= SHRT_MIN / b;\n}\n\n// stbi__err - error\n// stbi__errpf - error returning pointer to float\n// stbi__errpuc - error returning pointer to unsigned char\n\n#ifdef STBI_NO_FAILURE_STRINGS\n #define stbi__err(x,y) 0\n#elif defined(STBI_FAILURE_USERMSG)\n #define stbi__err(x,y) stbi__err(y)\n#else\n #define stbi__err(x,y) stbi__err(x)\n#endif\n\n#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL))\n#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL))\n\nSTBIDEF void stbi_image_free(void *retval_from_stbi_load)\n{\n STBI_FREE(retval_from_stbi_load);\n}\n\n#ifndef STBI_NO_LINEAR\nstatic float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp);\n#endif\n\n#ifndef STBI_NO_HDR\nstatic stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp);\n#endif\n\nstatic int stbi__vertically_flip_on_load_global = 0;\n\nSTBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)\n{\n stbi__vertically_flip_on_load_global = flag_true_if_should_flip;\n}\n\n#ifndef STBI_THREAD_LOCAL\n#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global\n#else\nstatic STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set;\n\nSTBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)\n{\n stbi__vertically_flip_on_load_local = flag_true_if_should_flip;\n stbi__vertically_flip_on_load_set = 1;\n}\n\n#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \\\n ? stbi__vertically_flip_on_load_local \\\n : stbi__vertically_flip_on_load_global)\n#endif // STBI_THREAD_LOCAL\n\nstatic void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)\n{\n memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields\n ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed\n ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order\n ri->num_channels = 0;\n\n // test the formats with a very explicit header first (at least a FOURCC\n // or distinctive magic number first)\n #ifndef STBI_NO_PNG\n if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri);\n #endif\n #ifndef STBI_NO_BMP\n if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri);\n #endif\n #ifndef STBI_NO_GIF\n if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri);\n #endif\n #ifndef STBI_NO_PSD\n if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc);\n #else\n STBI_NOTUSED(bpc);\n #endif\n #ifndef STBI_NO_PIC\n if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri);\n #endif\n\n // then the formats that can end up attempting to load with just 1 or 2\n // bytes matching expectations; these are prone to false positives, so\n // try them later\n #ifndef STBI_NO_JPEG\n if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri);\n #endif\n #ifndef STBI_NO_PNM\n if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri);\n #endif\n\n #ifndef STBI_NO_HDR\n if (stbi__hdr_test(s)) {\n float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri);\n return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp);\n }\n #endif\n\n #ifndef STBI_NO_TGA\n // test tga last because it's a crappy test!\n if (stbi__tga_test(s))\n return stbi__tga_load(s,x,y,comp,req_comp, ri);\n #endif\n\n return stbi__errpuc(\"unknown image type\", \"Image not of any known type, or corrupt\");\n}\n\nstatic stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)\n{\n int i;\n int img_len = w * h * channels;\n stbi_uc *reduced;\n\n reduced = (stbi_uc *) stbi__malloc(img_len);\n if (reduced == NULL) return stbi__errpuc(\"outofmem\", \"Out of memory\");\n\n for (i = 0; i < img_len; ++i)\n reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling\n\n STBI_FREE(orig);\n return reduced;\n}\n\nstatic stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)\n{\n int i;\n int img_len = w * h * channels;\n stbi__uint16 *enlarged;\n\n enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);\n if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc(\"outofmem\", \"Out of memory\");\n\n for (i = 0; i < img_len; ++i)\n enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff\n\n STBI_FREE(orig);\n return enlarged;\n}\n\nstatic void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel)\n{\n int row;\n size_t bytes_per_row = (size_t)w * bytes_per_pixel;\n stbi_uc temp[2048];\n stbi_uc *bytes = (stbi_uc *)image;\n\n for (row = 0; row < (h>>1); row++) {\n stbi_uc *row0 = bytes + row*bytes_per_row;\n stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row;\n // swap row0 with row1\n size_t bytes_left = bytes_per_row;\n while (bytes_left) {\n size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp);\n memcpy(temp, row0, bytes_copy);\n memcpy(row0, row1, bytes_copy);\n memcpy(row1, temp, bytes_copy);\n row0 += bytes_copy;\n row1 += bytes_copy;\n bytes_left -= bytes_copy;\n }\n }\n}\n\n#ifndef STBI_NO_GIF\nstatic void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel)\n{\n int slice;\n int slice_size = w * h * bytes_per_pixel;\n\n stbi_uc *bytes = (stbi_uc *)image;\n for (slice = 0; slice < z; ++slice) {\n stbi__vertical_flip(bytes, w, h, bytes_per_pixel);\n bytes += slice_size;\n }\n}\n#endif\n\nstatic unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)\n{\n stbi__result_info ri;\n void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);\n\n if (result == NULL)\n return NULL;\n\n // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.\n STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);\n\n if (ri.bits_per_channel != 8) {\n result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp);\n ri.bits_per_channel = 8;\n }\n\n // @TODO: move stbi__convert_format to here\n\n if (stbi__vertically_flip_on_load) {\n int channels = req_comp ? req_comp : *comp;\n stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc));\n }\n\n return (unsigned char *) result;\n}\n\nstatic stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)\n{\n stbi__result_info ri;\n void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);\n\n if (result == NULL)\n return NULL;\n\n // it is the responsibility of the loaders to make sure we get either 8 or 16 bit.\n STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16);\n\n if (ri.bits_per_channel != 16) {\n result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp);\n ri.bits_per_channel = 16;\n }\n\n // @TODO: move stbi__convert_format16 to here\n // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision\n\n if (stbi__vertically_flip_on_load) {\n int channels = req_comp ? req_comp : *comp;\n stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16));\n }\n\n return (stbi__uint16 *) result;\n}\n\n#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR)\nstatic void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp)\n{\n if (stbi__vertically_flip_on_load && result != NULL) {\n int channels = req_comp ? req_comp : *comp;\n stbi__vertical_flip(result, *x, *y, channels * sizeof(float));\n }\n}\n#endif\n\n#ifndef STBI_NO_STDIO\n\n#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)\nSTBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);\nSTBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);\n#endif\n\n#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)\nSTBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)\n{\n\treturn WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);\n}\n#endif\n\nstatic FILE *stbi__fopen(char const *filename, char const *mode)\n{\n FILE *f;\n#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8)\n wchar_t wMode[64];\n wchar_t wFilename[1024];\n\tif (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename)))\n return 0;\n\n\tif (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode)))\n return 0;\n\n#if defined(_MSC_VER) && _MSC_VER >= 1400\n\tif (0 != _wfopen_s(&f, wFilename, wMode))\n\t\tf = 0;\n#else\n f = _wfopen(wFilename, wMode);\n#endif\n\n#elif defined(_MSC_VER) && _MSC_VER >= 1400\n if (0 != fopen_s(&f, filename, mode))\n f=0;\n#else\n f = fopen(filename, mode);\n#endif\n return f;\n}\n\n\nSTBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)\n{\n FILE *f = stbi__fopen(filename, \"rb\");\n unsigned char *result;\n if (!f) return stbi__errpuc(\"can't fopen\", \"Unable to open file\");\n result = stbi_load_from_file(f,x,y,comp,req_comp);\n fclose(f);\n return result;\n}\n\nSTBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)\n{\n unsigned char *result;\n stbi__context s;\n stbi__start_file(&s,f);\n result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);\n if (result) {\n // need to 'unget' all the characters in the IO buffer\n fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);\n }\n return result;\n}\n\nSTBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)\n{\n stbi__uint16 *result;\n stbi__context s;\n stbi__start_file(&s,f);\n result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);\n if (result) {\n // need to 'unget' all the characters in the IO buffer\n fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR);\n }\n return result;\n}\n\nSTBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp)\n{\n FILE *f = stbi__fopen(filename, \"rb\");\n stbi__uint16 *result;\n if (!f) return (stbi_us *) stbi__errpuc(\"can't fopen\", \"Unable to open file\");\n result = stbi_load_from_file_16(f,x,y,comp,req_comp);\n fclose(f);\n return result;\n}\n\n\n#endif //!STBI_NO_STDIO\n\nSTBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)\n{\n stbi__context s;\n stbi__start_mem(&s,buffer,len);\n return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);\n}\n\nSTBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)\n{\n stbi__context s;\n stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);\n return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);\n}\n\nSTBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)\n{\n stbi__context s;\n stbi__start_mem(&s,buffer,len);\n return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);\n}\n\nSTBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)\n{\n stbi__context s;\n stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);\n return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);\n}\n\n#ifndef STBI_NO_GIF\nSTBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)\n{\n unsigned char *result;\n stbi__context s;\n stbi__start_mem(&s,buffer,len);\n\n result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);\n if (stbi__vertically_flip_on_load) {\n stbi__vertical_flip_slices( result, *x, *y, *z, *comp );\n }\n\n return result;\n}\n#endif\n\n#ifndef STBI_NO_LINEAR\nstatic float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)\n{\n unsigned char *data;\n #ifndef STBI_NO_HDR\n if (stbi__hdr_test(s)) {\n stbi__result_info ri;\n float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);\n if (hdr_data)\n stbi__float_postprocess(hdr_data,x,y,comp,req_comp);\n return hdr_data;\n }\n #endif\n data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp);\n if (data)\n return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp);\n return stbi__errpf(\"unknown image type\", \"Image not of any known type, or corrupt\");\n}\n\nSTBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)\n{\n stbi__context s;\n stbi__start_mem(&s,buffer,len);\n return stbi__loadf_main(&s,x,y,comp,req_comp);\n}\n\nSTBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)\n{\n stbi__context s;\n stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);\n return stbi__loadf_main(&s,x,y,comp,req_comp);\n}\n\n#ifndef STBI_NO_STDIO\nSTBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)\n{\n float *result;\n FILE *f = stbi__fopen(filename, \"rb\");\n if (!f) return stbi__errpf(\"can't fopen\", \"Unable to open file\");\n result = stbi_loadf_from_file(f,x,y,comp,req_comp);\n fclose(f);\n return result;\n}\n\nSTBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)\n{\n stbi__context s;\n stbi__start_file(&s,f);\n return stbi__loadf_main(&s,x,y,comp,req_comp);\n}\n#endif // !STBI_NO_STDIO\n\n#endif // !STBI_NO_LINEAR\n\n// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is\n// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always\n// reports false!\n\nSTBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)\n{\n #ifndef STBI_NO_HDR\n stbi__context s;\n stbi__start_mem(&s,buffer,len);\n return stbi__hdr_test(&s);\n #else\n STBI_NOTUSED(buffer);\n STBI_NOTUSED(len);\n return 0;\n #endif\n}\n\n#ifndef STBI_NO_STDIO\nSTBIDEF int stbi_is_hdr (char const *filename)\n{\n FILE *f = stbi__fopen(filename, \"rb\");\n int result=0;\n if (f) {\n result = stbi_is_hdr_from_file(f);\n fclose(f);\n }\n return result;\n}\n\nSTBIDEF int stbi_is_hdr_from_file(FILE *f)\n{\n #ifndef STBI_NO_HDR\n long pos = ftell(f);\n int res;\n stbi__context s;\n stbi__start_file(&s,f);\n res = stbi__hdr_test(&s);\n fseek(f, pos, SEEK_SET);\n return res;\n #else\n STBI_NOTUSED(f);\n return 0;\n #endif\n}\n#endif // !STBI_NO_STDIO\n\nSTBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user)\n{\n #ifndef STBI_NO_HDR\n stbi__context s;\n stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);\n return stbi__hdr_test(&s);\n #else\n STBI_NOTUSED(clbk);\n STBI_NOTUSED(user);\n return 0;\n #endif\n}\n\n#ifndef STBI_NO_LINEAR\nstatic float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f;\n\nSTBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; }\nSTBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; }\n#endif\n\nstatic float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f;\n\nSTBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; }\nSTBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; }\n\n\n//////////////////////////////////////////////////////////////////////////////\n//\n// Common code used by all image loaders\n//\n\nenum\n{\n STBI__SCAN_load=0,\n STBI__SCAN_type,\n STBI__SCAN_header\n};\n\nstatic void stbi__refill_buffer(stbi__context *s)\n{\n int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);\n s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);\n if (n == 0) {\n // at end of file, treat same as if from memory, but need to handle case\n // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file\n s->read_from_callbacks = 0;\n s->img_buffer = s->buffer_start;\n s->img_buffer_end = s->buffer_start+1;\n *s->img_buffer = 0;\n } else {\n s->img_buffer = s->buffer_start;\n s->img_buffer_end = s->buffer_start + n;\n }\n}\n\nstbi_inline static stbi_uc stbi__get8(stbi__context *s)\n{\n if (s->img_buffer < s->img_buffer_end)\n return *s->img_buffer++;\n if (s->read_from_callbacks) {\n stbi__refill_buffer(s);\n return *s->img_buffer++;\n }\n return 0;\n}\n\n#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)\n// nothing\n#else\nstbi_inline static int stbi__at_eof(stbi__context *s)\n{\n if (s->io.read) {\n if (!(s->io.eof)(s->io_user_data)) return 0;\n // if feof() is true, check if buffer = end\n // special case: we've only got the special 0 character at the end\n if (s->read_from_callbacks == 0) return 1;\n }\n\n return s->img_buffer >= s->img_buffer_end;\n}\n#endif\n\n#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC)\n// nothing\n#else\nstatic void stbi__skip(stbi__context *s, int n)\n{\n if (n == 0) return; // already there!\n if (n < 0) {\n s->img_buffer = s->img_buffer_end;\n return;\n }\n if (s->io.read) {\n int blen = (int) (s->img_buffer_end - s->img_buffer);\n if (blen < n) {\n s->img_buffer = s->img_buffer_end;\n (s->io.skip)(s->io_user_data, n - blen);\n return;\n }\n }\n s->img_buffer += n;\n}\n#endif\n\n#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM)\n// nothing\n#else\nstatic int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)\n{\n if (s->io.read) {\n int blen = (int) (s->img_buffer_end - s->img_buffer);\n if (blen < n) {\n int res, count;\n\n memcpy(buffer, s->img_buffer, blen);\n\n count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);\n res = (count == (n-blen));\n s->img_buffer = s->img_buffer_end;\n return res;\n }\n }\n\n if (s->img_buffer+n <= s->img_buffer_end) {\n memcpy(buffer, s->img_buffer, n);\n s->img_buffer += n;\n return 1;\n } else\n return 0;\n}\n#endif\n\n#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)\n// nothing\n#else\nstatic int stbi__get16be(stbi__context *s)\n{\n int z = stbi__get8(s);\n return (z << 8) + stbi__get8(s);\n}\n#endif\n\n#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC)\n// nothing\n#else\nstatic stbi__uint32 stbi__get32be(stbi__context *s)\n{\n stbi__uint32 z = stbi__get16be(s);\n return (z << 16) + stbi__get16be(s);\n}\n#endif\n\n#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF)\n// nothing\n#else\nstatic int stbi__get16le(stbi__context *s)\n{\n int z = stbi__get8(s);\n return z + (stbi__get8(s) << 8);\n}\n#endif\n\n#ifndef STBI_NO_BMP\nstatic stbi__uint32 stbi__get32le(stbi__context *s)\n{\n stbi__uint32 z = stbi__get16le(s);\n z += (stbi__uint32)stbi__get16le(s) << 16;\n return z;\n}\n#endif\n\n#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings\n\n#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)\n// nothing\n#else\n//////////////////////////////////////////////////////////////////////////////\n//\n// generic converter from built-in img_n to req_comp\n// individual types do this automatically as much as possible (e.g. jpeg\n// does all cases internally since it needs to colorspace convert anyway,\n// and it never has alpha, so very few cases ). png can automatically\n// interleave an alpha=255 channel, but falls back to this for other cases\n//\n// assume data buffer is malloced, so malloc a new one and free that one\n// only failure mode is malloc failing\n\nstatic stbi_uc stbi__compute_y(int r, int g, int b)\n{\n return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8);\n}\n#endif\n\n#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM)\n// nothing\n#else\nstatic unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y)\n{\n int i,j;\n unsigned char *good;\n\n if (req_comp == img_n) return data;\n STBI_ASSERT(req_comp >= 1 && req_comp <= 4);\n\n good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0);\n if (good == NULL) {\n STBI_FREE(data);\n return stbi__errpuc(\"outofmem\", \"Out of memory\");\n }\n\n for (j=0; j < (int) y; ++j) {\n unsigned char *src = data + j * x * img_n ;\n unsigned char *dest = good + j * x * req_comp;\n\n #define STBI__COMBO(a,b) ((a)*8+(b))\n #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)\n // convert source image with img_n components to one with req_comp components;\n // avoid switch per pixel, so use switch per scanline and massive macros\n switch (STBI__COMBO(img_n, req_comp)) {\n STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break;\n STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;\n STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break;\n STBI__CASE(2,1) { dest[0]=src[0]; } break;\n STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;\n STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;\n STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break;\n STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;\n STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break;\n STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break;\n STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break;\n STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;\n default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc(\"unsupported\", \"Unsupported format conversion\");\n }\n #undef STBI__CASE\n }\n\n STBI_FREE(data);\n return good;\n}\n#endif\n\n#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)\n// nothing\n#else\nstatic stbi__uint16 stbi__compute_y_16(int r, int g, int b)\n{\n return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8);\n}\n#endif\n\n#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD)\n// nothing\n#else\nstatic stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y)\n{\n int i,j;\n stbi__uint16 *good;\n\n if (req_comp == img_n) return data;\n STBI_ASSERT(req_comp >= 1 && req_comp <= 4);\n\n good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2);\n if (good == NULL) {\n STBI_FREE(data);\n return (stbi__uint16 *) stbi__errpuc(\"outofmem\", \"Out of memory\");\n }\n\n for (j=0; j < (int) y; ++j) {\n stbi__uint16 *src = data + j * x * img_n ;\n stbi__uint16 *dest = good + j * x * req_comp;\n\n #define STBI__COMBO(a,b) ((a)*8+(b))\n #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b)\n // convert source image with img_n components to one with req_comp components;\n // avoid switch per pixel, so use switch per scanline and massive macros\n switch (STBI__COMBO(img_n, req_comp)) {\n STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break;\n STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;\n STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break;\n STBI__CASE(2,1) { dest[0]=src[0]; } break;\n STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break;\n STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break;\n STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break;\n STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;\n STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break;\n STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break;\n STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break;\n STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break;\n default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc(\"unsupported\", \"Unsupported format conversion\");\n }\n #undef STBI__CASE\n }\n\n STBI_FREE(data);\n return good;\n}\n#endif\n\n#ifndef STBI_NO_LINEAR\nstatic float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp)\n{\n int i,k,n;\n float *output;\n if (!data) return NULL;\n output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0);\n if (output == NULL) { STBI_FREE(data); return stbi__errpf(\"outofmem\", \"Out of memory\"); }\n // compute number of non-alpha components\n if (comp & 1) n = comp; else n = comp-1;\n for (i=0; i < x*y; ++i) {\n for (k=0; k < n; ++k) {\n output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale);\n }\n }\n if (n < comp) {\n for (i=0; i < x*y; ++i) {\n output[i*comp + n] = data[i*comp + n]/255.0f;\n }\n }\n STBI_FREE(data);\n return output;\n}\n#endif\n\n#ifndef STBI_NO_HDR\n#define stbi__float2int(x) ((int) (x))\nstatic stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp)\n{\n int i,k,n;\n stbi_uc *output;\n if (!data) return NULL;\n output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0);\n if (output == NULL) { STBI_FREE(data); return stbi__errpuc(\"outofmem\", \"Out of memory\"); }\n // compute number of non-alpha components\n if (comp & 1) n = comp; else n = comp-1;\n for (i=0; i < x*y; ++i) {\n for (k=0; k < n; ++k) {\n float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f;\n if (z < 0) z = 0;\n if (z > 255) z = 255;\n output[i*comp + k] = (stbi_uc) stbi__float2int(z);\n }\n if (k < comp) {\n float z = data[i*comp+k] * 255 + 0.5f;\n if (z < 0) z = 0;\n if (z > 255) z = 255;\n output[i*comp + k] = (stbi_uc) stbi__float2int(z);\n }\n }\n STBI_FREE(data);\n return output;\n}\n#endif\n\n//////////////////////////////////////////////////////////////////////////////\n//\n// \"baseline\" JPEG/JFIF decoder\n//\n// simple implementation\n// - doesn't support delayed output of y-dimension\n// - simple interface (only one output format: 8-bit interleaved RGB)\n// - doesn't try to recover corrupt jpegs\n// - doesn't allow partial loading, loading multiple at once\n// - still fast on x86 (copying globals into locals doesn't help x86)\n// - allocates lots of intermediate memory (full size of all components)\n// - non-interleaved case requires this anyway\n// - allows good upsampling (see next)\n// high-quality\n// - upsampled channels are bilinearly interpolated, even across blocks\n// - quality integer IDCT derived from IJG's 'slow'\n// performance\n// - fast huffman; reasonable integer IDCT\n// - some SIMD kernels for common paths on targets with SSE2/NEON\n// - uses a lot of intermediate memory, could cache poorly\n\n#ifndef STBI_NO_JPEG\n\n// huffman decoding acceleration\n#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache\n\ntypedef struct\n{\n stbi_uc fast[1 << FAST_BITS];\n // weirdly, repacking this into AoS is a 10% speed loss, instead of a win\n stbi__uint16 code[256];\n stbi_uc values[256];\n stbi_uc size[257];\n unsigned int maxcode[18];\n int delta[17]; // old 'firstsymbol' - old 'firstcode'\n} stbi__huffman;\n\ntypedef struct\n{\n stbi__context *s;\n stbi__huffman huff_dc[4];\n stbi__huffman huff_ac[4];\n stbi__uint16 dequant[4][64];\n stbi__int16 fast_ac[4][1 << FAST_BITS];\n\n// sizes for components, interleaved MCUs\n int img_h_max, img_v_max;\n int img_mcu_x, img_mcu_y;\n int img_mcu_w, img_mcu_h;\n\n// definition of jpeg image component\n struct\n {\n int id;\n int h,v;\n int tq;\n int hd,ha;\n int dc_pred;\n\n int x,y,w2,h2;\n stbi_uc *data;\n void *raw_data, *raw_coeff;\n stbi_uc *linebuf;\n short *coeff; // progressive only\n int coeff_w, coeff_h; // number of 8x8 coefficient blocks\n } img_comp[4];\n\n stbi__uint32 code_buffer; // jpeg entropy-coded buffer\n int code_bits; // number of valid bits\n unsigned char marker; // marker seen while filling entropy buffer\n int nomore; // flag if we saw a marker so must stop\n\n int progressive;\n int spec_start;\n int spec_end;\n int succ_high;\n int succ_low;\n int eob_run;\n int jfif;\n int app14_color_transform; // Adobe APP14 tag\n int rgb;\n\n int scan_n, order[4];\n int restart_interval, todo;\n\n// kernels\n void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]);\n void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step);\n stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs);\n} stbi__jpeg;\n\nstatic int stbi__build_huffman(stbi__huffman *h, int *count)\n{\n int i,j,k=0;\n unsigned int code;\n // build size list for each symbol (from JPEG spec)\n for (i=0; i < 16; ++i) {\n for (j=0; j < count[i]; ++j) {\n h->size[k++] = (stbi_uc) (i+1);\n if(k >= 257) return stbi__err(\"bad size list\",\"Corrupt JPEG\");\n }\n }\n h->size[k] = 0;\n\n // compute actual symbols (from jpeg spec)\n code = 0;\n k = 0;\n for(j=1; j <= 16; ++j) {\n // compute delta to add to code to compute symbol id\n h->delta[j] = k - code;\n if (h->size[k] == j) {\n while (h->size[k] == j)\n h->code[k++] = (stbi__uint16) (code++);\n if (code-1 >= (1u << j)) return stbi__err(\"bad code lengths\",\"Corrupt JPEG\");\n }\n // compute largest code + 1 for this size, preshifted as needed later\n h->maxcode[j] = code << (16-j);\n code <<= 1;\n }\n h->maxcode[j] = 0xffffffff;\n\n // build non-spec acceleration table; 255 is flag for not-accelerated\n memset(h->fast, 255, 1 << FAST_BITS);\n for (i=0; i < k; ++i) {\n int s = h->size[i];\n if (s <= FAST_BITS) {\n int c = h->code[i] << (FAST_BITS-s);\n int m = 1 << (FAST_BITS-s);\n for (j=0; j < m; ++j) {\n h->fast[c+j] = (stbi_uc) i;\n }\n }\n }\n return 1;\n}\n\n// build a table that decodes both magnitude and value of small ACs in\n// one go.\nstatic void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h)\n{\n int i;\n for (i=0; i < (1 << FAST_BITS); ++i) {\n stbi_uc fast = h->fast[i];\n fast_ac[i] = 0;\n if (fast < 255) {\n int rs = h->values[fast];\n int run = (rs >> 4) & 15;\n int magbits = rs & 15;\n int len = h->size[fast];\n\n if (magbits && len + magbits <= FAST_BITS) {\n // magnitude code followed by receive_extend code\n int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);\n int m = 1 << (magbits - 1);\n if (k < m) k += (~0U << magbits) + 1;\n // if the result is small enough, we can fit it in fast_ac table\n if (k >= -128 && k <= 127)\n fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits));\n }\n }\n }\n}\n\nstatic void stbi__grow_buffer_unsafe(stbi__jpeg *j)\n{\n do {\n unsigned int b = j->nomore ? 0 : stbi__get8(j->s);\n if (b == 0xff) {\n int c = stbi__get8(j->s);\n while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes\n if (c != 0) {\n j->marker = (unsigned char) c;\n j->nomore = 1;\n return;\n }\n }\n j->code_buffer |= b << (24 - j->code_bits);\n j->code_bits += 8;\n } while (j->code_bits <= 24);\n}\n\n// (1 << n) - 1\nstatic const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535};\n\n// decode a jpeg huffman value from the bitstream\nstbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h)\n{\n unsigned int temp;\n int c,k;\n\n if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);\n\n // look at the top FAST_BITS and determine what symbol ID it is,\n // if the code is <= FAST_BITS\n c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);\n k = h->fast[c];\n if (k < 255) {\n int s = h->size[k];\n if (s > j->code_bits)\n return -1;\n j->code_buffer <<= s;\n j->code_bits -= s;\n return h->values[k];\n }\n\n // naive test is to shift the code_buffer down so k bits are\n // valid, then test against maxcode. To speed this up, we've\n // preshifted maxcode left so that it has (16-k) 0s at the\n // end; in other words, regardless of the number of bits, it\n // wants to be compared against something shifted to have 16;\n // that way we don't need to shift inside the loop.\n temp = j->code_buffer >> 16;\n for (k=FAST_BITS+1 ; ; ++k)\n if (temp < h->maxcode[k])\n break;\n if (k == 17) {\n // error! code not found\n j->code_bits -= 16;\n return -1;\n }\n\n if (k > j->code_bits)\n return -1;\n\n // convert the huffman code to the symbol id\n c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k];\n if(c < 0 || c >= 256) // symbol id out of bounds!\n return -1;\n STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]);\n\n // convert the id to a symbol\n j->code_bits -= k;\n j->code_buffer <<= k;\n return h->values[c];\n}\n\n// bias[n] = (-1<<n) + 1\nstatic const int stbi__jbias[16] = {0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};\n\n// combined JPEG 'receive' and JPEG 'extend', since baseline\n// always extends everything it receives.\nstbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)\n{\n unsigned int k;\n int sgn;\n if (j->code_bits < n) stbi__grow_buffer_unsafe(j);\n if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing\n\n sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative)\n k = stbi_lrot(j->code_buffer, n);\n j->code_buffer = k & ~stbi__bmask[n];\n k &= stbi__bmask[n];\n j->code_bits -= n;\n return k + (stbi__jbias[n] & (sgn - 1));\n}\n\n// get some unsigned bits\nstbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n)\n{\n unsigned int k;\n if (j->code_bits < n) stbi__grow_buffer_unsafe(j);\n if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing\n k = stbi_lrot(j->code_buffer, n);\n j->code_buffer = k & ~stbi__bmask[n];\n k &= stbi__bmask[n];\n j->code_bits -= n;\n return k;\n}\n\nstbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j)\n{\n unsigned int k;\n if (j->code_bits < 1) stbi__grow_buffer_unsafe(j);\n if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing\n k = j->code_buffer;\n j->code_buffer <<= 1;\n --j->code_bits;\n return k & 0x80000000;\n}\n\n// given a value that's at position X in the zigzag stream,\n// where does it appear in the 8x8 matrix coded as row-major?\nstatic const stbi_uc stbi__jpeg_dezigzag[64+15] =\n{\n 0, 1, 8, 16, 9, 2, 3, 10,\n 17, 24, 32, 25, 18, 11, 4, 5,\n 12, 19, 26, 33, 40, 48, 41, 34,\n 27, 20, 13, 6, 7, 14, 21, 28,\n 35, 42, 49, 56, 57, 50, 43, 36,\n 29, 22, 15, 23, 30, 37, 44, 51,\n 58, 59, 52, 45, 38, 31, 39, 46,\n 53, 60, 61, 54, 47, 55, 62, 63,\n // let corrupt input sample past end\n 63, 63, 63, 63, 63, 63, 63, 63,\n 63, 63, 63, 63, 63, 63, 63\n};\n\n// decode one 64-entry block--\nstatic int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)\n{\n int diff,dc,k;\n int t;\n\n if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);\n t = stbi__jpeg_huff_decode(j, hdc);\n if (t < 0 || t > 15) return stbi__err(\"bad huffman code\",\"Corrupt JPEG\");\n\n // 0 all the ac values now so we can do it 32-bits at a time\n memset(data,0,64*sizeof(data[0]));\n\n diff = t ? stbi__extend_receive(j, t) : 0;\n if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err(\"bad delta\",\"Corrupt JPEG\");\n dc = j->img_comp[b].dc_pred + diff;\n j->img_comp[b].dc_pred = dc;\n if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err(\"can't merge dc and ac\", \"Corrupt JPEG\");\n data[0] = (short) (dc * dequant[0]);\n\n // decode AC components, see JPEG spec\n k = 1;\n do {\n unsigned int zig;\n int c,r,s;\n if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);\n c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);\n r = fac[c];\n if (r) { // fast-AC path\n k += (r >> 4) & 15; // run\n s = r & 15; // combined length\n if (s > j->code_bits) return stbi__err(\"bad huffman code\", \"Combined length longer than code bits available\");\n j->code_buffer <<= s;\n j->code_bits -= s;\n // decode into unzigzag'd location\n zig = stbi__jpeg_dezigzag[k++];\n data[zig] = (short) ((r >> 8) * dequant[zig]);\n } else {\n int rs = stbi__jpeg_huff_decode(j, hac);\n if (rs < 0) return stbi__err(\"bad huffman code\",\"Corrupt JPEG\");\n s = rs & 15;\n r = rs >> 4;\n if (s == 0) {\n if (rs != 0xf0) break; // end block\n k += 16;\n } else {\n k += r;\n // decode into unzigzag'd location\n zig = stbi__jpeg_dezigzag[k++];\n data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);\n }\n }\n } while (k < 64);\n return 1;\n}\n\nstatic int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b)\n{\n int diff,dc;\n int t;\n if (j->spec_end != 0) return stbi__err(\"can't merge dc and ac\", \"Corrupt JPEG\");\n\n if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);\n\n if (j->succ_high == 0) {\n // first scan for DC coefficient, must be first\n memset(data,0,64*sizeof(data[0])); // 0 all the ac values now\n t = stbi__jpeg_huff_decode(j, hdc);\n if (t < 0 || t > 15) return stbi__err(\"can't merge dc and ac\", \"Corrupt JPEG\");\n diff = t ? stbi__extend_receive(j, t) : 0;\n\n if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err(\"bad delta\", \"Corrupt JPEG\");\n dc = j->img_comp[b].dc_pred + diff;\n j->img_comp[b].dc_pred = dc;\n if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err(\"can't merge dc and ac\", \"Corrupt JPEG\");\n data[0] = (short) (dc * (1 << j->succ_low));\n } else {\n // refinement scan for DC coefficient\n if (stbi__jpeg_get_bit(j))\n data[0] += (short) (1 << j->succ_low);\n }\n return 1;\n}\n\n// @OPTIMIZE: store non-zigzagged during the decode passes,\n// and only de-zigzag when dequantizing\nstatic int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac)\n{\n int k;\n if (j->spec_start == 0) return stbi__err(\"can't merge dc and ac\", \"Corrupt JPEG\");\n\n if (j->succ_high == 0) {\n int shift = j->succ_low;\n\n if (j->eob_run) {\n --j->eob_run;\n return 1;\n }\n\n k = j->spec_start;\n do {\n unsigned int zig;\n int c,r,s;\n if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);\n c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);\n r = fac[c];\n if (r) { // fast-AC path\n k += (r >> 4) & 15; // run\n s = r & 15; // combined length\n if (s > j->code_bits) return stbi__err(\"bad huffman code\", \"Combined length longer than code bits available\");\n j->code_buffer <<= s;\n j->code_bits -= s;\n zig = stbi__jpeg_dezigzag[k++];\n data[zig] = (short) ((r >> 8) * (1 << shift));\n } else {\n int rs = stbi__jpeg_huff_decode(j, hac);\n if (rs < 0) return stbi__err(\"bad huffman code\",\"Corrupt JPEG\");\n s = rs & 15;\n r = rs >> 4;\n if (s == 0) {\n if (r < 15) {\n j->eob_run = (1 << r);\n if (r)\n j->eob_run += stbi__jpeg_get_bits(j, r);\n --j->eob_run;\n break;\n }\n k += 16;\n } else {\n k += r;\n zig = stbi__jpeg_dezigzag[k++];\n data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift));\n }\n }\n } while (k <= j->spec_end);\n } else {\n // refinement scan for these AC coefficients\n\n short bit = (short) (1 << j->succ_low);\n\n if (j->eob_run) {\n --j->eob_run;\n for (k = j->spec_start; k <= j->spec_end; ++k) {\n short *p = &data[stbi__jpeg_dezigzag[k]];\n if (*p != 0)\n if (stbi__jpeg_get_bit(j))\n if ((*p & bit)==0) {\n if (*p > 0)\n *p += bit;\n else\n *p -= bit;\n }\n }\n } else {\n k = j->spec_start;\n do {\n int r,s;\n int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh\n if (rs < 0) return stbi__err(\"bad huffman code\",\"Corrupt JPEG\");\n s = rs & 15;\n r = rs >> 4;\n if (s == 0) {\n if (r < 15) {\n j->eob_run = (1 << r) - 1;\n if (r)\n j->eob_run += stbi__jpeg_get_bits(j, r);\n r = 64; // force end of block\n } else {\n // r=15 s=0 should write 16 0s, so we just do\n // a run of 15 0s and then write s (which is 0),\n // so we don't have to do anything special here\n }\n } else {\n if (s != 1) return stbi__err(\"bad huffman code\", \"Corrupt JPEG\");\n // sign bit\n if (stbi__jpeg_get_bit(j))\n s = bit;\n else\n s = -bit;\n }\n\n // advance by r\n while (k <= j->spec_end) {\n short *p = &data[stbi__jpeg_dezigzag[k++]];\n if (*p != 0) {\n if (stbi__jpeg_get_bit(j))\n if ((*p & bit)==0) {\n if (*p > 0)\n *p += bit;\n else\n *p -= bit;\n }\n } else {\n if (r == 0) {\n *p = (short) s;\n break;\n }\n --r;\n }\n }\n } while (k <= j->spec_end);\n }\n }\n return 1;\n}\n\n// take a -128..127 value and stbi__clamp it and convert to 0..255\nstbi_inline static stbi_uc stbi__clamp(int x)\n{\n // trick to use a single test to catch both cases\n if ((unsigned int) x > 255) {\n if (x < 0) return 0;\n if (x > 255) return 255;\n }\n return (stbi_uc) x;\n}\n\n#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5)))\n#define stbi__fsh(x) ((x) * 4096)\n\n// derived from jidctint -- DCT_ISLOW\n#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \\\n int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \\\n p2 = s2; \\\n p3 = s6; \\\n p1 = (p2+p3) * stbi__f2f(0.5411961f); \\\n t2 = p1 + p3*stbi__f2f(-1.847759065f); \\\n t3 = p1 + p2*stbi__f2f( 0.765366865f); \\\n p2 = s0; \\\n p3 = s4; \\\n t0 = stbi__fsh(p2+p3); \\\n t1 = stbi__fsh(p2-p3); \\\n x0 = t0+t3; \\\n x3 = t0-t3; \\\n x1 = t1+t2; \\\n x2 = t1-t2; \\\n t0 = s7; \\\n t1 = s5; \\\n t2 = s3; \\\n t3 = s1; \\\n p3 = t0+t2; \\\n p4 = t1+t3; \\\n p1 = t0+t3; \\\n p2 = t1+t2; \\\n p5 = (p3+p4)*stbi__f2f( 1.175875602f); \\\n t0 = t0*stbi__f2f( 0.298631336f); \\\n t1 = t1*stbi__f2f( 2.053119869f); \\\n t2 = t2*stbi__f2f( 3.072711026f); \\\n t3 = t3*stbi__f2f( 1.501321110f); \\\n p1 = p5 + p1*stbi__f2f(-0.899976223f); \\\n p2 = p5 + p2*stbi__f2f(-2.562915447f); \\\n p3 = p3*stbi__f2f(-1.961570560f); \\\n p4 = p4*stbi__f2f(-0.390180644f); \\\n t3 += p1+p4; \\\n t2 += p2+p3; \\\n t1 += p2+p4; \\\n t0 += p1+p3;\n\nstatic void stbi__idct_block(stbi_uc *out, int out_stride, short data[64])\n{\n int i,val[64],*v=val;\n stbi_uc *o;\n short *d = data;\n\n // columns\n for (i=0; i < 8; ++i,++d, ++v) {\n // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing\n if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0\n && d[40]==0 && d[48]==0 && d[56]==0) {\n // no shortcut 0 seconds\n // (1|2|3|4|5|6|7)==0 0 seconds\n // all separate -0.047 seconds\n // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds\n int dcterm = d[0]*4;\n v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm;\n } else {\n STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56])\n // constants scaled things up by 1<<12; let's bring them back\n // down, but keep 2 extra bits of precision\n x0 += 512; x1 += 512; x2 += 512; x3 += 512;\n v[ 0] = (x0+t3) >> 10;\n v[56] = (x0-t3) >> 10;\n v[ 8] = (x1+t2) >> 10;\n v[48] = (x1-t2) >> 10;\n v[16] = (x2+t1) >> 10;\n v[40] = (x2-t1) >> 10;\n v[24] = (x3+t0) >> 10;\n v[32] = (x3-t0) >> 10;\n }\n }\n\n for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) {\n // no fast case since the first 1D IDCT spread components out\n STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7])\n // constants scaled things up by 1<<12, plus we had 1<<2 from first\n // loop, plus horizontal and vertical each scale by sqrt(8) so together\n // we've got an extra 1<<3, so 1<<17 total we need to remove.\n // so we want to round that, which means adding 0.5 * 1<<17,\n // aka 65536. Also, we'll end up with -128 to 127 that we want\n // to encode as 0..255 by adding 128, so we'll add that before the shift\n x0 += 65536 + (128<<17);\n x1 += 65536 + (128<<17);\n x2 += 65536 + (128<<17);\n x3 += 65536 + (128<<17);\n // tried computing the shifts into temps, or'ing the temps to see\n // if any were out of range, but that was slower\n o[0] = stbi__clamp((x0+t3) >> 17);\n o[7] = stbi__clamp((x0-t3) >> 17);\n o[1] = stbi__clamp((x1+t2) >> 17);\n o[6] = stbi__clamp((x1-t2) >> 17);\n o[2] = stbi__clamp((x2+t1) >> 17);\n o[5] = stbi__clamp((x2-t1) >> 17);\n o[3] = stbi__clamp((x3+t0) >> 17);\n o[4] = stbi__clamp((x3-t0) >> 17);\n }\n}\n\n#ifdef STBI_SSE2\n// sse2 integer IDCT. not the fastest possible implementation but it\n// produces bit-identical results to the generic C version so it's\n// fully \"transparent\".\nstatic void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])\n{\n // This is constructed to match our regular (generic) integer IDCT exactly.\n __m128i row0, row1, row2, row3, row4, row5, row6, row7;\n __m128i tmp;\n\n // dot product constant: even elems=x, odd elems=y\n #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y))\n\n // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit)\n // out(1) = c1[even]*x + c1[odd]*y\n #define dct_rot(out0,out1, x,y,c0,c1) \\\n __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \\\n __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \\\n __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \\\n __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \\\n __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \\\n __m128i out1##_h = _mm_madd_epi16(c0##hi, c1)\n\n // out = in << 12 (in 16-bit, out 32-bit)\n #define dct_widen(out, in) \\\n __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \\\n __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4)\n\n // wide add\n #define dct_wadd(out, a, b) \\\n __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \\\n __m128i out##_h = _mm_add_epi32(a##_h, b##_h)\n\n // wide sub\n #define dct_wsub(out, a, b) \\\n __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \\\n __m128i out##_h = _mm_sub_epi32(a##_h, b##_h)\n\n // butterfly a/b, add bias, then shift by \"s\" and pack\n #define dct_bfly32o(out0, out1, a,b,bias,s) \\\n { \\\n __m128i abiased_l = _mm_add_epi32(a##_l, bias); \\\n __m128i abiased_h = _mm_add_epi32(a##_h, bias); \\\n dct_wadd(sum, abiased, b); \\\n dct_wsub(dif, abiased, b); \\\n out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \\\n out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \\\n }\n\n // 8-bit interleave step (for transposes)\n #define dct_interleave8(a, b) \\\n tmp = a; \\\n a = _mm_unpacklo_epi8(a, b); \\\n b = _mm_unpackhi_epi8(tmp, b)\n\n // 16-bit interleave step (for transposes)\n #define dct_interleave16(a, b) \\\n tmp = a; \\\n a = _mm_unpacklo_epi16(a, b); \\\n b = _mm_unpackhi_epi16(tmp, b)\n\n #define dct_pass(bias,shift) \\\n { \\\n /* even part */ \\\n dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \\\n __m128i sum04 = _mm_add_epi16(row0, row4); \\\n __m128i dif04 = _mm_sub_epi16(row0, row4); \\\n dct_widen(t0e, sum04); \\\n dct_widen(t1e, dif04); \\\n dct_wadd(x0, t0e, t3e); \\\n dct_wsub(x3, t0e, t3e); \\\n dct_wadd(x1, t1e, t2e); \\\n dct_wsub(x2, t1e, t2e); \\\n /* odd part */ \\\n dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \\\n dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \\\n __m128i sum17 = _mm_add_epi16(row1, row7); \\\n __m128i sum35 = _mm_add_epi16(row3, row5); \\\n dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \\\n dct_wadd(x4, y0o, y4o); \\\n dct_wadd(x5, y1o, y5o); \\\n dct_wadd(x6, y2o, y5o); \\\n dct_wadd(x7, y3o, y4o); \\\n dct_bfly32o(row0,row7, x0,x7,bias,shift); \\\n dct_bfly32o(row1,row6, x1,x6,bias,shift); \\\n dct_bfly32o(row2,row5, x2,x5,bias,shift); \\\n dct_bfly32o(row3,row4, x3,x4,bias,shift); \\\n }\n\n __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f));\n __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f));\n __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f));\n __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f));\n __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f));\n __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f));\n __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f));\n __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f));\n\n // rounding biases in column/row passes, see stbi__idct_block for explanation.\n __m128i bias_0 = _mm_set1_epi32(512);\n __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17));\n\n // load\n row0 = _mm_load_si128((const __m128i *) (data + 0*8));\n row1 = _mm_load_si128((const __m128i *) (data + 1*8));\n row2 = _mm_load_si128((const __m128i *) (data + 2*8));\n row3 = _mm_load_si128((const __m128i *) (data + 3*8));\n row4 = _mm_load_si128((const __m128i *) (data + 4*8));\n row5 = _mm_load_si128((const __m128i *) (data + 5*8));\n row6 = _mm_load_si128((const __m128i *) (data + 6*8));\n row7 = _mm_load_si128((const __m128i *) (data + 7*8));\n\n // column pass\n dct_pass(bias_0, 10);\n\n {\n // 16bit 8x8 transpose pass 1\n dct_interleave16(row0, row4);\n dct_interleave16(row1, row5);\n dct_interleave16(row2, row6);\n dct_interleave16(row3, row7);\n\n // transpose pass 2\n dct_interleave16(row0, row2);\n dct_interleave16(row1, row3);\n dct_interleave16(row4, row6);\n dct_interleave16(row5, row7);\n\n // transpose pass 3\n dct_interleave16(row0, row1);\n dct_interleave16(row2, row3);\n dct_interleave16(row4, row5);\n dct_interleave16(row6, row7);\n }\n\n // row pass\n dct_pass(bias_1, 17);\n\n {\n // pack\n __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7\n __m128i p1 = _mm_packus_epi16(row2, row3);\n __m128i p2 = _mm_packus_epi16(row4, row5);\n __m128i p3 = _mm_packus_epi16(row6, row7);\n\n // 8bit 8x8 transpose pass 1\n dct_interleave8(p0, p2); // a0e0a1e1...\n dct_interleave8(p1, p3); // c0g0c1g1...\n\n // transpose pass 2\n dct_interleave8(p0, p1); // a0c0e0g0...\n dct_interleave8(p2, p3); // b0d0f0h0...\n\n // transpose pass 3\n dct_interleave8(p0, p2); // a0b0c0d0...\n dct_interleave8(p1, p3); // a4b4c4d4...\n\n // store\n _mm_storel_epi64((__m128i *) out, p0); out += out_stride;\n _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride;\n _mm_storel_epi64((__m128i *) out, p2); out += out_stride;\n _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride;\n _mm_storel_epi64((__m128i *) out, p1); out += out_stride;\n _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride;\n _mm_storel_epi64((__m128i *) out, p3); out += out_stride;\n _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e));\n }\n\n#undef dct_const\n#undef dct_rot\n#undef dct_widen\n#undef dct_wadd\n#undef dct_wsub\n#undef dct_bfly32o\n#undef dct_interleave8\n#undef dct_interleave16\n#undef dct_pass\n}\n\n#endif // STBI_SSE2\n\n#ifdef STBI_NEON\n\n// NEON integer IDCT. should produce bit-identical\n// results to the generic C version.\nstatic void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])\n{\n int16x8_t row0, row1, row2, row3, row4, row5, row6, row7;\n\n int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f));\n int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f));\n int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f));\n int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f));\n int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f));\n int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f));\n int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f));\n int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f));\n int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f));\n int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f));\n int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f));\n int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f));\n\n#define dct_long_mul(out, inq, coeff) \\\n int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \\\n int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff)\n\n#define dct_long_mac(out, acc, inq, coeff) \\\n int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \\\n int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff)\n\n#define dct_widen(out, inq) \\\n int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \\\n int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12)\n\n// wide add\n#define dct_wadd(out, a, b) \\\n int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \\\n int32x4_t out##_h = vaddq_s32(a##_h, b##_h)\n\n// wide sub\n#define dct_wsub(out, a, b) \\\n int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \\\n int32x4_t out##_h = vsubq_s32(a##_h, b##_h)\n\n// butterfly a/b, then shift using \"shiftop\" by \"s\" and pack\n#define dct_bfly32o(out0,out1, a,b,shiftop,s) \\\n { \\\n dct_wadd(sum, a, b); \\\n dct_wsub(dif, a, b); \\\n out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \\\n out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \\\n }\n\n#define dct_pass(shiftop, shift) \\\n { \\\n /* even part */ \\\n int16x8_t sum26 = vaddq_s16(row2, row6); \\\n dct_long_mul(p1e, sum26, rot0_0); \\\n dct_long_mac(t2e, p1e, row6, rot0_1); \\\n dct_long_mac(t3e, p1e, row2, rot0_2); \\\n int16x8_t sum04 = vaddq_s16(row0, row4); \\\n int16x8_t dif04 = vsubq_s16(row0, row4); \\\n dct_widen(t0e, sum04); \\\n dct_widen(t1e, dif04); \\\n dct_wadd(x0, t0e, t3e); \\\n dct_wsub(x3, t0e, t3e); \\\n dct_wadd(x1, t1e, t2e); \\\n dct_wsub(x2, t1e, t2e); \\\n /* odd part */ \\\n int16x8_t sum15 = vaddq_s16(row1, row5); \\\n int16x8_t sum17 = vaddq_s16(row1, row7); \\\n int16x8_t sum35 = vaddq_s16(row3, row5); \\\n int16x8_t sum37 = vaddq_s16(row3, row7); \\\n int16x8_t sumodd = vaddq_s16(sum17, sum35); \\\n dct_long_mul(p5o, sumodd, rot1_0); \\\n dct_long_mac(p1o, p5o, sum17, rot1_1); \\\n dct_long_mac(p2o, p5o, sum35, rot1_2); \\\n dct_long_mul(p3o, sum37, rot2_0); \\\n dct_long_mul(p4o, sum15, rot2_1); \\\n dct_wadd(sump13o, p1o, p3o); \\\n dct_wadd(sump24o, p2o, p4o); \\\n dct_wadd(sump23o, p2o, p3o); \\\n dct_wadd(sump14o, p1o, p4o); \\\n dct_long_mac(x4, sump13o, row7, rot3_0); \\\n dct_long_mac(x5, sump24o, row5, rot3_1); \\\n dct_long_mac(x6, sump23o, row3, rot3_2); \\\n dct_long_mac(x7, sump14o, row1, rot3_3); \\\n dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \\\n dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \\\n dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \\\n dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \\\n }\n\n // load\n row0 = vld1q_s16(data + 0*8);\n row1 = vld1q_s16(data + 1*8);\n row2 = vld1q_s16(data + 2*8);\n row3 = vld1q_s16(data + 3*8);\n row4 = vld1q_s16(data + 4*8);\n row5 = vld1q_s16(data + 5*8);\n row6 = vld1q_s16(data + 6*8);\n row7 = vld1q_s16(data + 7*8);\n\n // add DC bias\n row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0));\n\n // column pass\n dct_pass(vrshrn_n_s32, 10);\n\n // 16bit 8x8 transpose\n {\n// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively.\n// whether compilers actually get this is another story, sadly.\n#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; }\n#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); }\n#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); }\n\n // pass 1\n dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6\n dct_trn16(row2, row3);\n dct_trn16(row4, row5);\n dct_trn16(row6, row7);\n\n // pass 2\n dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4\n dct_trn32(row1, row3);\n dct_trn32(row4, row6);\n dct_trn32(row5, row7);\n\n // pass 3\n dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0\n dct_trn64(row1, row5);\n dct_trn64(row2, row6);\n dct_trn64(row3, row7);\n\n#undef dct_trn16\n#undef dct_trn32\n#undef dct_trn64\n }\n\n // row pass\n // vrshrn_n_s32 only supports shifts up to 16, we need\n // 17. so do a non-rounding shift of 16 first then follow\n // up with a rounding shift by 1.\n dct_pass(vshrn_n_s32, 16);\n\n {\n // pack and round\n uint8x8_t p0 = vqrshrun_n_s16(row0, 1);\n uint8x8_t p1 = vqrshrun_n_s16(row1, 1);\n uint8x8_t p2 = vqrshrun_n_s16(row2, 1);\n uint8x8_t p3 = vqrshrun_n_s16(row3, 1);\n uint8x8_t p4 = vqrshrun_n_s16(row4, 1);\n uint8x8_t p5 = vqrshrun_n_s16(row5, 1);\n uint8x8_t p6 = vqrshrun_n_s16(row6, 1);\n uint8x8_t p7 = vqrshrun_n_s16(row7, 1);\n\n // again, these can translate into one instruction, but often don't.\n#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; }\n#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); }\n#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); }\n\n // sadly can't use interleaved stores here since we only write\n // 8 bytes to each scan line!\n\n // 8x8 8-bit transpose pass 1\n dct_trn8_8(p0, p1);\n dct_trn8_8(p2, p3);\n dct_trn8_8(p4, p5);\n dct_trn8_8(p6, p7);\n\n // pass 2\n dct_trn8_16(p0, p2);\n dct_trn8_16(p1, p3);\n dct_trn8_16(p4, p6);\n dct_trn8_16(p5, p7);\n\n // pass 3\n dct_trn8_32(p0, p4);\n dct_trn8_32(p1, p5);\n dct_trn8_32(p2, p6);\n dct_trn8_32(p3, p7);\n\n // store\n vst1_u8(out, p0); out += out_stride;\n vst1_u8(out, p1); out += out_stride;\n vst1_u8(out, p2); out += out_stride;\n vst1_u8(out, p3); out += out_stride;\n vst1_u8(out, p4); out += out_stride;\n vst1_u8(out, p5); out += out_stride;\n vst1_u8(out, p6); out += out_stride;\n vst1_u8(out, p7);\n\n#undef dct_trn8_8\n#undef dct_trn8_16\n#undef dct_trn8_32\n }\n\n#undef dct_long_mul\n#undef dct_long_mac\n#undef dct_widen\n#undef dct_wadd\n#undef dct_wsub\n#undef dct_bfly32o\n#undef dct_pass\n}\n\n#endif // STBI_NEON\n\n#define STBI__MARKER_none 0xff\n// if there's a pending marker from the entropy stream, return that\n// otherwise, fetch from the stream and get a marker. if there's no\n// marker, return 0xff, which is never a valid marker value\nstatic stbi_uc stbi__get_marker(stbi__jpeg *j)\n{\n stbi_uc x;\n if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }\n x = stbi__get8(j->s);\n if (x != 0xff) return STBI__MARKER_none;\n while (x == 0xff)\n x = stbi__get8(j->s); // consume repeated 0xff fill bytes\n return x;\n}\n\n// in each scan, we'll have scan_n components, and the order\n// of the components is specified by order[]\n#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)\n\n// after a restart interval, stbi__jpeg_reset the entropy decoder and\n// the dc prediction\nstatic void stbi__jpeg_reset(stbi__jpeg *j)\n{\n j->code_bits = 0;\n j->code_buffer = 0;\n j->nomore = 0;\n j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0;\n j->marker = STBI__MARKER_none;\n j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff;\n j->eob_run = 0;\n // no more than 1<<31 MCUs if no restart_interal? that's plenty safe,\n // since we don't even allow 1<<30 pixels\n}\n\nstatic int stbi__parse_entropy_coded_data(stbi__jpeg *z)\n{\n stbi__jpeg_reset(z);\n if (!z->progressive) {\n if (z->scan_n == 1) {\n int i,j;\n STBI_SIMD_ALIGN(short, data[64]);\n int n = z->order[0];\n // non-interleaved data, we just need to process one block at a time,\n // in trivial scanline order\n // number of blocks to do just depends on how many actual \"pixels\" this\n // component has, independent of interleaved MCU blocking and such\n int w = (z->img_comp[n].x+7) >> 3;\n int h = (z->img_comp[n].y+7) >> 3;\n for (j=0; j < h; ++j) {\n for (i=0; i < w; ++i) {\n int ha = z->img_comp[n].ha;\n if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;\n z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);\n // every data block is an MCU, so countdown the restart interval\n if (--z->todo <= 0) {\n if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);\n // if it's NOT a restart, then just bail, so we get corrupt data\n // rather than no data\n if (!STBI__RESTART(z->marker)) return 1;\n stbi__jpeg_reset(z);\n }\n }\n }\n return 1;\n } else { // interleaved\n int i,j,k,x,y;\n STBI_SIMD_ALIGN(short, data[64]);\n for (j=0; j < z->img_mcu_y; ++j) {\n for (i=0; i < z->img_mcu_x; ++i) {\n // scan an interleaved mcu... process scan_n components in order\n for (k=0; k < z->scan_n; ++k) {\n int n = z->order[k];\n // scan out an mcu's worth of this component; that's just determined\n // by the basic H and V specified for the component\n for (y=0; y < z->img_comp[n].v; ++y) {\n for (x=0; x < z->img_comp[n].h; ++x) {\n int x2 = (i*z->img_comp[n].h + x)*8;\n int y2 = (j*z->img_comp[n].v + y)*8;\n int ha = z->img_comp[n].ha;\n if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0;\n z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data);\n }\n }\n }\n // after all interleaved components, that's an interleaved MCU,\n // so now count down the restart interval\n if (--z->todo <= 0) {\n if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);\n if (!STBI__RESTART(z->marker)) return 1;\n stbi__jpeg_reset(z);\n }\n }\n }\n return 1;\n }\n } else {\n if (z->scan_n == 1) {\n int i,j;\n int n = z->order[0];\n // non-interleaved data, we just need to process one block at a time,\n // in trivial scanline order\n // number of blocks to do just depends on how many actual \"pixels\" this\n // component has, independent of interleaved MCU blocking and such\n int w = (z->img_comp[n].x+7) >> 3;\n int h = (z->img_comp[n].y+7) >> 3;\n for (j=0; j < h; ++j) {\n for (i=0; i < w; ++i) {\n short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);\n if (z->spec_start == 0) {\n if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))\n return 0;\n } else {\n int ha = z->img_comp[n].ha;\n if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha]))\n return 0;\n }\n // every data block is an MCU, so countdown the restart interval\n if (--z->todo <= 0) {\n if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);\n if (!STBI__RESTART(z->marker)) return 1;\n stbi__jpeg_reset(z);\n }\n }\n }\n return 1;\n } else { // interleaved\n int i,j,k,x,y;\n for (j=0; j < z->img_mcu_y; ++j) {\n for (i=0; i < z->img_mcu_x; ++i) {\n // scan an interleaved mcu... process scan_n components in order\n for (k=0; k < z->scan_n; ++k) {\n int n = z->order[k];\n // scan out an mcu's worth of this component; that's just determined\n // by the basic H and V specified for the component\n for (y=0; y < z->img_comp[n].v; ++y) {\n for (x=0; x < z->img_comp[n].h; ++x) {\n int x2 = (i*z->img_comp[n].h + x);\n int y2 = (j*z->img_comp[n].v + y);\n short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w);\n if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n))\n return 0;\n }\n }\n }\n // after all interleaved components, that's an interleaved MCU,\n // so now count down the restart interval\n if (--z->todo <= 0) {\n if (z->code_bits < 24) stbi__grow_buffer_unsafe(z);\n if (!STBI__RESTART(z->marker)) return 1;\n stbi__jpeg_reset(z);\n }\n }\n }\n return 1;\n }\n }\n}\n\nstatic void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant)\n{\n int i;\n for (i=0; i < 64; ++i)\n data[i] *= dequant[i];\n}\n\nstatic void stbi__jpeg_finish(stbi__jpeg *z)\n{\n if (z->progressive) {\n // dequantize and idct the data\n int i,j,n;\n for (n=0; n < z->s->img_n; ++n) {\n int w = (z->img_comp[n].x+7) >> 3;\n int h = (z->img_comp[n].y+7) >> 3;\n for (j=0; j < h; ++j) {\n for (i=0; i < w; ++i) {\n short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w);\n stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]);\n z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data);\n }\n }\n }\n }\n}\n\nstatic int stbi__process_marker(stbi__jpeg *z, int m)\n{\n int L;\n switch (m) {\n case STBI__MARKER_none: // no marker found\n return stbi__err(\"expected marker\",\"Corrupt JPEG\");\n\n case 0xDD: // DRI - specify restart interval\n if (stbi__get16be(z->s) != 4) return stbi__err(\"bad DRI len\",\"Corrupt JPEG\");\n z->restart_interval = stbi__get16be(z->s);\n return 1;\n\n case 0xDB: // DQT - define quantization table\n L = stbi__get16be(z->s)-2;\n while (L > 0) {\n int q = stbi__get8(z->s);\n int p = q >> 4, sixteen = (p != 0);\n int t = q & 15,i;\n if (p != 0 && p != 1) return stbi__err(\"bad DQT type\",\"Corrupt JPEG\");\n if (t > 3) return stbi__err(\"bad DQT table\",\"Corrupt JPEG\");\n\n for (i=0; i < 64; ++i)\n z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s));\n L -= (sixteen ? 129 : 65);\n }\n return L==0;\n\n case 0xC4: // DHT - define huffman table\n L = stbi__get16be(z->s)-2;\n while (L > 0) {\n stbi_uc *v;\n int sizes[16],i,n=0;\n int q = stbi__get8(z->s);\n int tc = q >> 4;\n int th = q & 15;\n if (tc > 1 || th > 3) return stbi__err(\"bad DHT header\",\"Corrupt JPEG\");\n for (i=0; i < 16; ++i) {\n sizes[i] = stbi__get8(z->s);\n n += sizes[i];\n }\n if(n > 256) return stbi__err(\"bad DHT header\",\"Corrupt JPEG\"); // Loop over i < n would write past end of values!\n L -= 17;\n if (tc == 0) {\n if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0;\n v = z->huff_dc[th].values;\n } else {\n if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0;\n v = z->huff_ac[th].values;\n }\n for (i=0; i < n; ++i)\n v[i] = stbi__get8(z->s);\n if (tc != 0)\n stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th);\n L -= n;\n }\n return L==0;\n }\n\n // check for comment block or APP blocks\n if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) {\n L = stbi__get16be(z->s);\n if (L < 2) {\n if (m == 0xFE)\n return stbi__err(\"bad COM len\",\"Corrupt JPEG\");\n else\n return stbi__err(\"bad APP len\",\"Corrupt JPEG\");\n }\n L -= 2;\n\n if (m == 0xE0 && L >= 5) { // JFIF APP0 segment\n static const unsigned char tag[5] = {'J','F','I','F','\\0'};\n int ok = 1;\n int i;\n for (i=0; i < 5; ++i)\n if (stbi__get8(z->s) != tag[i])\n ok = 0;\n L -= 5;\n if (ok)\n z->jfif = 1;\n } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment\n static const unsigned char tag[6] = {'A','d','o','b','e','\\0'};\n int ok = 1;\n int i;\n for (i=0; i < 6; ++i)\n if (stbi__get8(z->s) != tag[i])\n ok = 0;\n L -= 6;\n if (ok) {\n stbi__get8(z->s); // version\n stbi__get16be(z->s); // flags0\n stbi__get16be(z->s); // flags1\n z->app14_color_transform = stbi__get8(z->s); // color transform\n L -= 6;\n }\n }\n\n stbi__skip(z->s, L);\n return 1;\n }\n\n return stbi__err(\"unknown marker\",\"Corrupt JPEG\");\n}\n\n// after we see SOS\nstatic int stbi__process_scan_header(stbi__jpeg *z)\n{\n int i;\n int Ls = stbi__get16be(z->s);\n z->scan_n = stbi__get8(z->s);\n if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err(\"bad SOS component count\",\"Corrupt JPEG\");\n if (Ls != 6+2*z->scan_n) return stbi__err(\"bad SOS len\",\"Corrupt JPEG\");\n for (i=0; i < z->scan_n; ++i) {\n int id = stbi__get8(z->s), which;\n int q = stbi__get8(z->s);\n for (which = 0; which < z->s->img_n; ++which)\n if (z->img_comp[which].id == id)\n break;\n if (which == z->s->img_n) return 0; // no match\n z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err(\"bad DC huff\",\"Corrupt JPEG\");\n z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err(\"bad AC huff\",\"Corrupt JPEG\");\n z->order[i] = which;\n }\n\n {\n int aa;\n z->spec_start = stbi__get8(z->s);\n z->spec_end = stbi__get8(z->s); // should be 63, but might be 0\n aa = stbi__get8(z->s);\n z->succ_high = (aa >> 4);\n z->succ_low = (aa & 15);\n if (z->progressive) {\n if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13)\n return stbi__err(\"bad SOS\", \"Corrupt JPEG\");\n } else {\n if (z->spec_start != 0) return stbi__err(\"bad SOS\",\"Corrupt JPEG\");\n if (z->succ_high != 0 || z->succ_low != 0) return stbi__err(\"bad SOS\",\"Corrupt JPEG\");\n z->spec_end = 63;\n }\n }\n\n return 1;\n}\n\nstatic int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)\n{\n int i;\n for (i=0; i < ncomp; ++i) {\n if (z->img_comp[i].raw_data) {\n STBI_FREE(z->img_comp[i].raw_data);\n z->img_comp[i].raw_data = NULL;\n z->img_comp[i].data = NULL;\n }\n if (z->img_comp[i].raw_coeff) {\n STBI_FREE(z->img_comp[i].raw_coeff);\n z->img_comp[i].raw_coeff = 0;\n z->img_comp[i].coeff = 0;\n }\n if (z->img_comp[i].linebuf) {\n STBI_FREE(z->img_comp[i].linebuf);\n z->img_comp[i].linebuf = NULL;\n }\n }\n return why;\n}\n\nstatic int stbi__process_frame_header(stbi__jpeg *z, int scan)\n{\n stbi__context *s = z->s;\n int Lf,p,i,q, h_max=1,v_max=1,c;\n Lf = stbi__get16be(s); if (Lf < 11) return stbi__err(\"bad SOF len\",\"Corrupt JPEG\"); // JPEG\n p = stbi__get8(s); if (p != 8) return stbi__err(\"only 8-bit\",\"JPEG format not supported: 8-bit only\"); // JPEG baseline\n s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err(\"no header height\", \"JPEG format not supported: delayed height\"); // Legal, but we don't handle it--but neither does IJG\n s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err(\"0 width\",\"Corrupt JPEG\"); // JPEG requires\n if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err(\"too large\",\"Very large image (corrupt?)\");\n if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err(\"too large\",\"Very large image (corrupt?)\");\n c = stbi__get8(s);\n if (c != 3 && c != 1 && c != 4) return stbi__err(\"bad component count\",\"Corrupt JPEG\");\n s->img_n = c;\n for (i=0; i < c; ++i) {\n z->img_comp[i].data = NULL;\n z->img_comp[i].linebuf = NULL;\n }\n\n if (Lf != 8+3*s->img_n) return stbi__err(\"bad SOF len\",\"Corrupt JPEG\");\n\n z->rgb = 0;\n for (i=0; i < s->img_n; ++i) {\n static const unsigned char rgb[3] = { 'R', 'G', 'B' };\n z->img_comp[i].id = stbi__get8(s);\n if (s->img_n == 3 && z->img_comp[i].id == rgb[i])\n ++z->rgb;\n q = stbi__get8(s);\n z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err(\"bad H\",\"Corrupt JPEG\");\n z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err(\"bad V\",\"Corrupt JPEG\");\n z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err(\"bad TQ\",\"Corrupt JPEG\");\n }\n\n if (scan != STBI__SCAN_load) return 1;\n\n if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err(\"too large\", \"Image too large to decode\");\n\n for (i=0; i < s->img_n; ++i) {\n if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h;\n if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v;\n }\n\n // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios\n // and I've never seen a non-corrupted JPEG file actually use them\n for (i=0; i < s->img_n; ++i) {\n if (h_max % z->img_comp[i].h != 0) return stbi__err(\"bad H\",\"Corrupt JPEG\");\n if (v_max % z->img_comp[i].v != 0) return stbi__err(\"bad V\",\"Corrupt JPEG\");\n }\n\n // compute interleaved mcu info\n z->img_h_max = h_max;\n z->img_v_max = v_max;\n z->img_mcu_w = h_max * 8;\n z->img_mcu_h = v_max * 8;\n // these sizes can't be more than 17 bits\n z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w;\n z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h;\n\n for (i=0; i < s->img_n; ++i) {\n // number of effective pixels (e.g. for non-interleaved MCU)\n z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max;\n z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max;\n // to simplify generation, we'll allocate enough memory to decode\n // the bogus oversized data from using interleaved MCUs and their\n // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't\n // discard the extra data until colorspace conversion\n //\n // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier)\n // so these muls can't overflow with 32-bit ints (which we require)\n z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8;\n z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8;\n z->img_comp[i].coeff = 0;\n z->img_comp[i].raw_coeff = 0;\n z->img_comp[i].linebuf = NULL;\n z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15);\n if (z->img_comp[i].raw_data == NULL)\n return stbi__free_jpeg_components(z, i+1, stbi__err(\"outofmem\", \"Out of memory\"));\n // align blocks for idct using mmx/sse\n z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15);\n if (z->progressive) {\n // w2, h2 are multiples of 8 (see above)\n z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8;\n z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8;\n z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15);\n if (z->img_comp[i].raw_coeff == NULL)\n return stbi__free_jpeg_components(z, i+1, stbi__err(\"outofmem\", \"Out of memory\"));\n z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15);\n }\n }\n\n return 1;\n}\n\n// use comparisons since in some cases we handle more than one case (e.g. SOF)\n#define stbi__DNL(x) ((x) == 0xdc)\n#define stbi__SOI(x) ((x) == 0xd8)\n#define stbi__EOI(x) ((x) == 0xd9)\n#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)\n#define stbi__SOS(x) ((x) == 0xda)\n\n#define stbi__SOF_progressive(x) ((x) == 0xc2)\n\nstatic int stbi__decode_jpeg_header(stbi__jpeg *z, int scan)\n{\n int m;\n z->jfif = 0;\n z->app14_color_transform = -1; // valid values are 0,1,2\n z->marker = STBI__MARKER_none; // initialize cached marker to empty\n m = stbi__get_marker(z);\n if (!stbi__SOI(m)) return stbi__err(\"no SOI\",\"Corrupt JPEG\");\n if (scan == STBI__SCAN_type) return 1;\n m = stbi__get_marker(z);\n while (!stbi__SOF(m)) {\n if (!stbi__process_marker(z,m)) return 0;\n m = stbi__get_marker(z);\n while (m == STBI__MARKER_none) {\n // some files have extra padding after their blocks, so ok, we'll scan\n if (stbi__at_eof(z->s)) return stbi__err(\"no SOF\", \"Corrupt JPEG\");\n m = stbi__get_marker(z);\n }\n }\n z->progressive = stbi__SOF_progressive(m);\n if (!stbi__process_frame_header(z, scan)) return 0;\n return 1;\n}\n\nstatic stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j)\n{\n // some JPEGs have junk at end, skip over it but if we find what looks\n // like a valid marker, resume there\n while (!stbi__at_eof(j->s)) {\n stbi_uc x = stbi__get8(j->s);\n while (x == 0xff) { // might be a marker\n if (stbi__at_eof(j->s)) return STBI__MARKER_none;\n x = stbi__get8(j->s);\n if (x != 0x00 && x != 0xff) {\n // not a stuffed zero or lead-in to another marker, looks\n // like an actual marker, return it\n return x;\n }\n // stuffed zero has x=0 now which ends the loop, meaning we go\n // back to regular scan loop.\n // repeated 0xff keeps trying to read the next byte of the marker.\n }\n }\n return STBI__MARKER_none;\n}\n\n// decode image to YCbCr format\nstatic int stbi__decode_jpeg_image(stbi__jpeg *j)\n{\n int m;\n for (m = 0; m < 4; m++) {\n j->img_comp[m].raw_data = NULL;\n j->img_comp[m].raw_coeff = NULL;\n }\n j->restart_interval = 0;\n if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;\n m = stbi__get_marker(j);\n while (!stbi__EOI(m)) {\n if (stbi__SOS(m)) {\n if (!stbi__process_scan_header(j)) return 0;\n if (!stbi__parse_entropy_coded_data(j)) return 0;\n if (j->marker == STBI__MARKER_none ) {\n j->marker = stbi__skip_jpeg_junk_at_end(j);\n // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0\n }\n m = stbi__get_marker(j);\n if (STBI__RESTART(m))\n m = stbi__get_marker(j);\n } else if (stbi__DNL(m)) {\n int Ld = stbi__get16be(j->s);\n stbi__uint32 NL = stbi__get16be(j->s);\n if (Ld != 4) return stbi__err(\"bad DNL len\", \"Corrupt JPEG\");\n if (NL != j->s->img_y) return stbi__err(\"bad DNL height\", \"Corrupt JPEG\");\n m = stbi__get_marker(j);\n } else {\n if (!stbi__process_marker(j, m)) return 1;\n m = stbi__get_marker(j);\n }\n }\n if (j->progressive)\n stbi__jpeg_finish(j);\n return 1;\n}\n\n// static jfif-centered resampling (across block boundaries)\n\ntypedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1,\n int w, int hs);\n\n#define stbi__div4(x) ((stbi_uc) ((x) >> 2))\n\nstatic stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)\n{\n STBI_NOTUSED(out);\n STBI_NOTUSED(in_far);\n STBI_NOTUSED(w);\n STBI_NOTUSED(hs);\n return in_near;\n}\n\nstatic stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)\n{\n // need to generate two samples vertically for every one in input\n int i;\n STBI_NOTUSED(hs);\n for (i=0; i < w; ++i)\n out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);\n return out;\n}\n\nstatic stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)\n{\n // need to generate two samples horizontally for every one in input\n int i;\n stbi_uc *input = in_near;\n\n if (w == 1) {\n // if only one sample, can't do any interpolation\n out[0] = out[1] = input[0];\n return out;\n }\n\n out[0] = input[0];\n out[1] = stbi__div4(input[0]*3 + input[1] + 2);\n for (i=1; i < w-1; ++i) {\n int n = 3*input[i]+2;\n out[i*2+0] = stbi__div4(n+input[i-1]);\n out[i*2+1] = stbi__div4(n+input[i+1]);\n }\n out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2);\n out[i*2+1] = input[w-1];\n\n STBI_NOTUSED(in_far);\n STBI_NOTUSED(hs);\n\n return out;\n}\n\n#define stbi__div16(x) ((stbi_uc) ((x) >> 4))\n\nstatic stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)\n{\n // need to generate 2x2 samples for every one in input\n int i,t0,t1;\n if (w == 1) {\n out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);\n return out;\n }\n\n t1 = 3*in_near[0] + in_far[0];\n out[0] = stbi__div4(t1+2);\n for (i=1; i < w; ++i) {\n t0 = t1;\n t1 = 3*in_near[i]+in_far[i];\n out[i*2-1] = stbi__div16(3*t0 + t1 + 8);\n out[i*2 ] = stbi__div16(3*t1 + t0 + 8);\n }\n out[w*2-1] = stbi__div4(t1+2);\n\n STBI_NOTUSED(hs);\n\n return out;\n}\n\n#if defined(STBI_SSE2) || defined(STBI_NEON)\nstatic stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)\n{\n // need to generate 2x2 samples for every one in input\n int i=0,t0,t1;\n\n if (w == 1) {\n out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);\n return out;\n }\n\n t1 = 3*in_near[0] + in_far[0];\n // process groups of 8 pixels for as long as we can.\n // note we can't handle the last pixel in a row in this loop\n // because we need to handle the filter boundary conditions.\n for (; i < ((w-1) & ~7); i += 8) {\n#if defined(STBI_SSE2)\n // load and perform the vertical filtering pass\n // this uses 3*x + y = 4*x + (y - x)\n __m128i zero = _mm_setzero_si128();\n __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i));\n __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i));\n __m128i farw = _mm_unpacklo_epi8(farb, zero);\n __m128i nearw = _mm_unpacklo_epi8(nearb, zero);\n __m128i diff = _mm_sub_epi16(farw, nearw);\n __m128i nears = _mm_slli_epi16(nearw, 2);\n __m128i curr = _mm_add_epi16(nears, diff); // current row\n\n // horizontal filter works the same based on shifted vers of current\n // row. \"prev\" is current row shifted right by 1 pixel; we need to\n // insert the previous pixel value (from t1).\n // \"next\" is current row shifted left by 1 pixel, with first pixel\n // of next block of 8 pixels added in.\n __m128i prv0 = _mm_slli_si128(curr, 2);\n __m128i nxt0 = _mm_srli_si128(curr, 2);\n __m128i prev = _mm_insert_epi16(prv0, t1, 0);\n __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7);\n\n // horizontal filter, polyphase implementation since it's convenient:\n // even pixels = 3*cur + prev = cur*4 + (prev - cur)\n // odd pixels = 3*cur + next = cur*4 + (next - cur)\n // note the shared term.\n __m128i bias = _mm_set1_epi16(8);\n __m128i curs = _mm_slli_epi16(curr, 2);\n __m128i prvd = _mm_sub_epi16(prev, curr);\n __m128i nxtd = _mm_sub_epi16(next, curr);\n __m128i curb = _mm_add_epi16(curs, bias);\n __m128i even = _mm_add_epi16(prvd, curb);\n __m128i odd = _mm_add_epi16(nxtd, curb);\n\n // interleave even and odd pixels, then undo scaling.\n __m128i int0 = _mm_unpacklo_epi16(even, odd);\n __m128i int1 = _mm_unpackhi_epi16(even, odd);\n __m128i de0 = _mm_srli_epi16(int0, 4);\n __m128i de1 = _mm_srli_epi16(int1, 4);\n\n // pack and write output\n __m128i outv = _mm_packus_epi16(de0, de1);\n _mm_storeu_si128((__m128i *) (out + i*2), outv);\n#elif defined(STBI_NEON)\n // load and perform the vertical filtering pass\n // this uses 3*x + y = 4*x + (y - x)\n uint8x8_t farb = vld1_u8(in_far + i);\n uint8x8_t nearb = vld1_u8(in_near + i);\n int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb));\n int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2));\n int16x8_t curr = vaddq_s16(nears, diff); // current row\n\n // horizontal filter works the same based on shifted vers of current\n // row. \"prev\" is current row shifted right by 1 pixel; we need to\n // insert the previous pixel value (from t1).\n // \"next\" is current row shifted left by 1 pixel, with first pixel\n // of next block of 8 pixels added in.\n int16x8_t prv0 = vextq_s16(curr, curr, 7);\n int16x8_t nxt0 = vextq_s16(curr, curr, 1);\n int16x8_t prev = vsetq_lane_s16(t1, prv0, 0);\n int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7);\n\n // horizontal filter, polyphase implementation since it's convenient:\n // even pixels = 3*cur + prev = cur*4 + (prev - cur)\n // odd pixels = 3*cur + next = cur*4 + (next - cur)\n // note the shared term.\n int16x8_t curs = vshlq_n_s16(curr, 2);\n int16x8_t prvd = vsubq_s16(prev, curr);\n int16x8_t nxtd = vsubq_s16(next, curr);\n int16x8_t even = vaddq_s16(curs, prvd);\n int16x8_t odd = vaddq_s16(curs, nxtd);\n\n // undo scaling and round, then store with even/odd phases interleaved\n uint8x8x2_t o;\n o.val[0] = vqrshrun_n_s16(even, 4);\n o.val[1] = vqrshrun_n_s16(odd, 4);\n vst2_u8(out + i*2, o);\n#endif\n\n // \"previous\" value for next iter\n t1 = 3*in_near[i+7] + in_far[i+7];\n }\n\n t0 = t1;\n t1 = 3*in_near[i] + in_far[i];\n out[i*2] = stbi__div16(3*t1 + t0 + 8);\n\n for (++i; i < w; ++i) {\n t0 = t1;\n t1 = 3*in_near[i]+in_far[i];\n out[i*2-1] = stbi__div16(3*t0 + t1 + 8);\n out[i*2 ] = stbi__div16(3*t1 + t0 + 8);\n }\n out[w*2-1] = stbi__div4(t1+2);\n\n STBI_NOTUSED(hs);\n\n return out;\n}\n#endif\n\nstatic stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)\n{\n // resample with nearest-neighbor\n int i,j;\n STBI_NOTUSED(in_far);\n for (i=0; i < w; ++i)\n for (j=0; j < hs; ++j)\n out[i*hs+j] = in_near[i];\n return out;\n}\n\n// this is a reduced-precision calculation of YCbCr-to-RGB introduced\n// to make sure the code produces the same results in both SIMD and scalar\n#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8)\nstatic void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)\n{\n int i;\n for (i=0; i < count; ++i) {\n int y_fixed = (y[i] << 20) + (1<<19); // rounding\n int r,g,b;\n int cr = pcr[i] - 128;\n int cb = pcb[i] - 128;\n r = y_fixed + cr* stbi__float2fixed(1.40200f);\n g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);\n b = y_fixed + cb* stbi__float2fixed(1.77200f);\n r >>= 20;\n g >>= 20;\n b >>= 20;\n if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }\n if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }\n if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }\n out[0] = (stbi_uc)r;\n out[1] = (stbi_uc)g;\n out[2] = (stbi_uc)b;\n out[3] = 255;\n out += step;\n }\n}\n\n#if defined(STBI_SSE2) || defined(STBI_NEON)\nstatic void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)\n{\n int i = 0;\n\n#ifdef STBI_SSE2\n // step == 3 is pretty ugly on the final interleave, and i'm not convinced\n // it's useful in practice (you wouldn't use it for textures, for example).\n // so just accelerate step == 4 case.\n if (step == 4) {\n // this is a fairly straightforward implementation and not super-optimized.\n __m128i signflip = _mm_set1_epi8(-0x80);\n __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f));\n __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f));\n __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f));\n __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f));\n __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128);\n __m128i xw = _mm_set1_epi16(255); // alpha channel\n\n for (; i+7 < count; i += 8) {\n // load\n __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i));\n __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i));\n __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i));\n __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128\n __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128\n\n // unpack to short (and left-shift cr, cb by 8)\n __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes);\n __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased);\n __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased);\n\n // color transform\n __m128i yws = _mm_srli_epi16(yw, 4);\n __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw);\n __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw);\n __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1);\n __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1);\n __m128i rws = _mm_add_epi16(cr0, yws);\n __m128i gwt = _mm_add_epi16(cb0, yws);\n __m128i bws = _mm_add_epi16(yws, cb1);\n __m128i gws = _mm_add_epi16(gwt, cr1);\n\n // descale\n __m128i rw = _mm_srai_epi16(rws, 4);\n __m128i bw = _mm_srai_epi16(bws, 4);\n __m128i gw = _mm_srai_epi16(gws, 4);\n\n // back to byte, set up for transpose\n __m128i brb = _mm_packus_epi16(rw, bw);\n __m128i gxb = _mm_packus_epi16(gw, xw);\n\n // transpose to interleave channels\n __m128i t0 = _mm_unpacklo_epi8(brb, gxb);\n __m128i t1 = _mm_unpackhi_epi8(brb, gxb);\n __m128i o0 = _mm_unpacklo_epi16(t0, t1);\n __m128i o1 = _mm_unpackhi_epi16(t0, t1);\n\n // store\n _mm_storeu_si128((__m128i *) (out + 0), o0);\n _mm_storeu_si128((__m128i *) (out + 16), o1);\n out += 32;\n }\n }\n#endif\n\n#ifdef STBI_NEON\n // in this version, step=3 support would be easy to add. but is there demand?\n if (step == 4) {\n // this is a fairly straightforward implementation and not super-optimized.\n uint8x8_t signflip = vdup_n_u8(0x80);\n int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f));\n int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f));\n int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f));\n int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f));\n\n for (; i+7 < count; i += 8) {\n // load\n uint8x8_t y_bytes = vld1_u8(y + i);\n uint8x8_t cr_bytes = vld1_u8(pcr + i);\n uint8x8_t cb_bytes = vld1_u8(pcb + i);\n int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip));\n int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip));\n\n // expand to s16\n int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4));\n int16x8_t crw = vshll_n_s8(cr_biased, 7);\n int16x8_t cbw = vshll_n_s8(cb_biased, 7);\n\n // color transform\n int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0);\n int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0);\n int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1);\n int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1);\n int16x8_t rws = vaddq_s16(yws, cr0);\n int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1);\n int16x8_t bws = vaddq_s16(yws, cb1);\n\n // undo scaling, round, convert to byte\n uint8x8x4_t o;\n o.val[0] = vqrshrun_n_s16(rws, 4);\n o.val[1] = vqrshrun_n_s16(gws, 4);\n o.val[2] = vqrshrun_n_s16(bws, 4);\n o.val[3] = vdup_n_u8(255);\n\n // store, interleaving r/g/b/a\n vst4_u8(out, o);\n out += 8*4;\n }\n }\n#endif\n\n for (; i < count; ++i) {\n int y_fixed = (y[i] << 20) + (1<<19); // rounding\n int r,g,b;\n int cr = pcr[i] - 128;\n int cb = pcb[i] - 128;\n r = y_fixed + cr* stbi__float2fixed(1.40200f);\n g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000);\n b = y_fixed + cb* stbi__float2fixed(1.77200f);\n r >>= 20;\n g >>= 20;\n b >>= 20;\n if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; }\n if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; }\n if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; }\n out[0] = (stbi_uc)r;\n out[1] = (stbi_uc)g;\n out[2] = (stbi_uc)b;\n out[3] = 255;\n out += step;\n }\n}\n#endif\n\n// set up the kernels\nstatic void stbi__setup_jpeg(stbi__jpeg *j)\n{\n j->idct_block_kernel = stbi__idct_block;\n j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;\n j->resample_row_hv_2_kernel = stbi__resample_row_hv_2;\n\n#ifdef STBI_SSE2\n if (stbi__sse2_available()) {\n j->idct_block_kernel = stbi__idct_simd;\n j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;\n j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;\n }\n#endif\n\n#ifdef STBI_NEON\n j->idct_block_kernel = stbi__idct_simd;\n j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd;\n j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd;\n#endif\n}\n\n// clean up the temporary component buffers\nstatic void stbi__cleanup_jpeg(stbi__jpeg *j)\n{\n stbi__free_jpeg_components(j, j->s->img_n, 0);\n}\n\ntypedef struct\n{\n resample_row_func resample;\n stbi_uc *line0,*line1;\n int hs,vs; // expansion factor in each axis\n int w_lores; // horizontal pixels pre-expansion\n int ystep; // how far through vertical expansion we are\n int ypos; // which pre-expansion row we're on\n} stbi__resample;\n\n// fast 0..255 * 0..255 => 0..255 rounded multiplication\nstatic stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y)\n{\n unsigned int t = x*y + 128;\n return (stbi_uc) ((t + (t >>8)) >> 8);\n}\n\nstatic stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp)\n{\n int n, decode_n, is_rgb;\n z->s->img_n = 0; // make stbi__cleanup_jpeg safe\n\n // validate req_comp\n if (req_comp < 0 || req_comp > 4) return stbi__errpuc(\"bad req_comp\", \"Internal error\");\n\n // load a jpeg image from whichever source, but leave in YCbCr format\n if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; }\n\n // determine actual number of components to generate\n n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1;\n\n is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif));\n\n if (z->s->img_n == 3 && n < 3 && !is_rgb)\n decode_n = 1;\n else\n decode_n = z->s->img_n;\n\n // nothing to do if no components requested; check this now to avoid\n // accessing uninitialized coutput[0] later\n if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; }\n\n // resample and color-convert\n {\n int k;\n unsigned int i,j;\n stbi_uc *output;\n stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL };\n\n stbi__resample res_comp[4];\n\n for (k=0; k < decode_n; ++k) {\n stbi__resample *r = &res_comp[k];\n\n // allocate line buffer big enough for upsampling off the edges\n // with upsample factor of 4\n z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3);\n if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc(\"outofmem\", \"Out of memory\"); }\n\n r->hs = z->img_h_max / z->img_comp[k].h;\n r->vs = z->img_v_max / z->img_comp[k].v;\n r->ystep = r->vs >> 1;\n r->w_lores = (z->s->img_x + r->hs-1) / r->hs;\n r->ypos = 0;\n r->line0 = r->line1 = z->img_comp[k].data;\n\n if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1;\n else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2;\n else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2;\n else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel;\n else r->resample = stbi__resample_row_generic;\n }\n\n // can't error after this so, this is safe\n output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1);\n if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc(\"outofmem\", \"Out of memory\"); }\n\n // now go ahead and resample\n for (j=0; j < z->s->img_y; ++j) {\n stbi_uc *out = output + n * z->s->img_x * j;\n for (k=0; k < decode_n; ++k) {\n stbi__resample *r = &res_comp[k];\n int y_bot = r->ystep >= (r->vs >> 1);\n coutput[k] = r->resample(z->img_comp[k].linebuf,\n y_bot ? r->line1 : r->line0,\n y_bot ? r->line0 : r->line1,\n r->w_lores, r->hs);\n if (++r->ystep >= r->vs) {\n r->ystep = 0;\n r->line0 = r->line1;\n if (++r->ypos < z->img_comp[k].y)\n r->line1 += z->img_comp[k].w2;\n }\n }\n if (n >= 3) {\n stbi_uc *y = coutput[0];\n if (z->s->img_n == 3) {\n if (is_rgb) {\n for (i=0; i < z->s->img_x; ++i) {\n out[0] = y[i];\n out[1] = coutput[1][i];\n out[2] = coutput[2][i];\n out[3] = 255;\n out += n;\n }\n } else {\n z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);\n }\n } else if (z->s->img_n == 4) {\n if (z->app14_color_transform == 0) { // CMYK\n for (i=0; i < z->s->img_x; ++i) {\n stbi_uc m = coutput[3][i];\n out[0] = stbi__blinn_8x8(coutput[0][i], m);\n out[1] = stbi__blinn_8x8(coutput[1][i], m);\n out[2] = stbi__blinn_8x8(coutput[2][i], m);\n out[3] = 255;\n out += n;\n }\n } else if (z->app14_color_transform == 2) { // YCCK\n z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);\n for (i=0; i < z->s->img_x; ++i) {\n stbi_uc m = coutput[3][i];\n out[0] = stbi__blinn_8x8(255 - out[0], m);\n out[1] = stbi__blinn_8x8(255 - out[1], m);\n out[2] = stbi__blinn_8x8(255 - out[2], m);\n out += n;\n }\n } else { // YCbCr + alpha? Ignore the fourth channel for now\n z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n);\n }\n } else\n for (i=0; i < z->s->img_x; ++i) {\n out[0] = out[1] = out[2] = y[i];\n out[3] = 255; // not used if n==3\n out += n;\n }\n } else {\n if (is_rgb) {\n if (n == 1)\n for (i=0; i < z->s->img_x; ++i)\n *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);\n else {\n for (i=0; i < z->s->img_x; ++i, out += 2) {\n out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]);\n out[1] = 255;\n }\n }\n } else if (z->s->img_n == 4 && z->app14_color_transform == 0) {\n for (i=0; i < z->s->img_x; ++i) {\n stbi_uc m = coutput[3][i];\n stbi_uc r = stbi__blinn_8x8(coutput[0][i], m);\n stbi_uc g = stbi__blinn_8x8(coutput[1][i], m);\n stbi_uc b = stbi__blinn_8x8(coutput[2][i], m);\n out[0] = stbi__compute_y(r, g, b);\n out[1] = 255;\n out += n;\n }\n } else if (z->s->img_n == 4 && z->app14_color_transform == 2) {\n for (i=0; i < z->s->img_x; ++i) {\n out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]);\n out[1] = 255;\n out += n;\n }\n } else {\n stbi_uc *y = coutput[0];\n if (n == 1)\n for (i=0; i < z->s->img_x; ++i) out[i] = y[i];\n else\n for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; }\n }\n }\n }\n stbi__cleanup_jpeg(z);\n *out_x = z->s->img_x;\n *out_y = z->s->img_y;\n if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output\n return output;\n }\n}\n\nstatic void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)\n{\n unsigned char* result;\n stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg));\n if (!j) return stbi__errpuc(\"outofmem\", \"Out of memory\");\n memset(j, 0, sizeof(stbi__jpeg));\n STBI_NOTUSED(ri);\n j->s = s;\n stbi__setup_jpeg(j);\n result = load_jpeg_image(j, x,y,comp,req_comp);\n STBI_FREE(j);\n return result;\n}\n\nstatic int stbi__jpeg_test(stbi__context *s)\n{\n int r;\n stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));\n if (!j) return stbi__err(\"outofmem\", \"Out of memory\");\n memset(j, 0, sizeof(stbi__jpeg));\n j->s = s;\n stbi__setup_jpeg(j);\n r = stbi__decode_jpeg_header(j, STBI__SCAN_type);\n stbi__rewind(s);\n STBI_FREE(j);\n return r;\n}\n\nstatic int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp)\n{\n if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) {\n stbi__rewind( j->s );\n return 0;\n }\n if (x) *x = j->s->img_x;\n if (y) *y = j->s->img_y;\n if (comp) *comp = j->s->img_n >= 3 ? 3 : 1;\n return 1;\n}\n\nstatic int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp)\n{\n int result;\n stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg)));\n if (!j) return stbi__err(\"outofmem\", \"Out of memory\");\n memset(j, 0, sizeof(stbi__jpeg));\n j->s = s;\n result = stbi__jpeg_info_raw(j, x, y, comp);\n STBI_FREE(j);\n return result;\n}\n#endif\n\n// public domain zlib decode v0.2 Sean Barrett 2006-11-18\n// simple implementation\n// - all input must be provided in an upfront buffer\n// - all output is written to a single output buffer (can malloc/realloc)\n// performance\n// - fast huffman\n\n#ifndef STBI_NO_ZLIB\n\n// fast-way is faster to check than jpeg huffman, but slow way is slower\n#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables\n#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1)\n#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet\n\n// zlib-style huffman encoding\n// (jpegs packs from left, zlib from right, so can't share code)\ntypedef struct\n{\n stbi__uint16 fast[1 << STBI__ZFAST_BITS];\n stbi__uint16 firstcode[16];\n int maxcode[17];\n stbi__uint16 firstsymbol[16];\n stbi_uc size[STBI__ZNSYMS];\n stbi__uint16 value[STBI__ZNSYMS];\n} stbi__zhuffman;\n\nstbi_inline static int stbi__bitreverse16(int n)\n{\n n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1);\n n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2);\n n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4);\n n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8);\n return n;\n}\n\nstbi_inline static int stbi__bit_reverse(int v, int bits)\n{\n STBI_ASSERT(bits <= 16);\n // to bit reverse n bits, reverse 16 and shift\n // e.g. 11 bits, bit reverse and shift away 5\n return stbi__bitreverse16(v) >> (16-bits);\n}\n\nstatic int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)\n{\n int i,k=0;\n int code, next_code[16], sizes[17];\n\n // DEFLATE spec for generating codes\n memset(sizes, 0, sizeof(sizes));\n memset(z->fast, 0, sizeof(z->fast));\n for (i=0; i < num; ++i)\n ++sizes[sizelist[i]];\n sizes[0] = 0;\n for (i=1; i < 16; ++i)\n if (sizes[i] > (1 << i))\n return stbi__err(\"bad sizes\", \"Corrupt PNG\");\n code = 0;\n for (i=1; i < 16; ++i) {\n next_code[i] = code;\n z->firstcode[i] = (stbi__uint16) code;\n z->firstsymbol[i] = (stbi__uint16) k;\n code = (code + sizes[i]);\n if (sizes[i])\n if (code-1 >= (1 << i)) return stbi__err(\"bad codelengths\",\"Corrupt PNG\");\n z->maxcode[i] = code << (16-i); // preshift for inner loop\n code <<= 1;\n k += sizes[i];\n }\n z->maxcode[16] = 0x10000; // sentinel\n for (i=0; i < num; ++i) {\n int s = sizelist[i];\n if (s) {\n int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s];\n stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i);\n z->size [c] = (stbi_uc ) s;\n z->value[c] = (stbi__uint16) i;\n if (s <= STBI__ZFAST_BITS) {\n int j = stbi__bit_reverse(next_code[s],s);\n while (j < (1 << STBI__ZFAST_BITS)) {\n z->fast[j] = fastv;\n j += (1 << s);\n }\n }\n ++next_code[s];\n }\n }\n return 1;\n}\n\n// zlib-from-memory implementation for PNG reading\n// because PNG allows splitting the zlib stream arbitrarily,\n// and it's annoying structurally to have PNG call ZLIB call PNG,\n// we require PNG read all the IDATs and combine them into a single\n// memory buffer\n\ntypedef struct\n{\n stbi_uc *zbuffer, *zbuffer_end;\n int num_bits;\n int hit_zeof_once;\n stbi__uint32 code_buffer;\n\n char *zout;\n char *zout_start;\n char *zout_end;\n int z_expandable;\n\n stbi__zhuffman z_length, z_distance;\n} stbi__zbuf;\n\nstbi_inline static int stbi__zeof(stbi__zbuf *z)\n{\n return (z->zbuffer >= z->zbuffer_end);\n}\n\nstbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z)\n{\n return stbi__zeof(z) ? 0 : *z->zbuffer++;\n}\n\nstatic void stbi__fill_bits(stbi__zbuf *z)\n{\n do {\n if (z->code_buffer >= (1U << z->num_bits)) {\n z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */\n return;\n }\n z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;\n z->num_bits += 8;\n } while (z->num_bits <= 24);\n}\n\nstbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n)\n{\n unsigned int k;\n if (z->num_bits < n) stbi__fill_bits(z);\n k = z->code_buffer & ((1 << n) - 1);\n z->code_buffer >>= n;\n z->num_bits -= n;\n return k;\n}\n\nstatic int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z)\n{\n int b,s,k;\n // not resolved by fast table, so compute it the slow way\n // use jpeg approach, which requires MSbits at top\n k = stbi__bit_reverse(a->code_buffer, 16);\n for (s=STBI__ZFAST_BITS+1; ; ++s)\n if (k < z->maxcode[s])\n break;\n if (s >= 16) return -1; // invalid code!\n // code size is s, so:\n b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s];\n if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere!\n if (z->size[b] != s) return -1; // was originally an assert, but report failure instead.\n a->code_buffer >>= s;\n a->num_bits -= s;\n return z->value[b];\n}\n\nstbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z)\n{\n int b,s;\n if (a->num_bits < 16) {\n if (stbi__zeof(a)) {\n if (!a->hit_zeof_once) {\n // This is the first time we hit eof, insert 16 extra padding btis\n // to allow us to keep going; if we actually consume any of them\n // though, that is invalid data. This is caught later.\n a->hit_zeof_once = 1;\n a->num_bits += 16; // add 16 implicit zero bits\n } else {\n // We already inserted our extra 16 padding bits and are again\n // out, this stream is actually prematurely terminated.\n return -1;\n }\n } else {\n stbi__fill_bits(a);\n }\n }\n b = z->fast[a->code_buffer & STBI__ZFAST_MASK];\n if (b) {\n s = b >> 9;\n a->code_buffer >>= s;\n a->num_bits -= s;\n return b & 511;\n }\n return stbi__zhuffman_decode_slowpath(a, z);\n}\n\nstatic int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes\n{\n char *q;\n unsigned int cur, limit, old_limit;\n z->zout = zout;\n if (!z->z_expandable) return stbi__err(\"output buffer limit\",\"Corrupt PNG\");\n cur = (unsigned int) (z->zout - z->zout_start);\n limit = old_limit = (unsigned) (z->zout_end - z->zout_start);\n if (UINT_MAX - cur < (unsigned) n) return stbi__err(\"outofmem\", \"Out of memory\");\n while (cur + n > limit) {\n if(limit > UINT_MAX / 2) return stbi__err(\"outofmem\", \"Out of memory\");\n limit *= 2;\n }\n q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit);\n STBI_NOTUSED(old_limit);\n if (q == NULL) return stbi__err(\"outofmem\", \"Out of memory\");\n z->zout_start = q;\n z->zout = q + cur;\n z->zout_end = q + limit;\n return 1;\n}\n\nstatic const int stbi__zlength_base[31] = {\n 3,4,5,6,7,8,9,10,11,13,\n 15,17,19,23,27,31,35,43,51,59,\n 67,83,99,115,131,163,195,227,258,0,0 };\n\nstatic const int stbi__zlength_extra[31]=\n{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 };\n\nstatic const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,\n257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0};\n\nstatic const int stbi__zdist_extra[32] =\n{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};\n\nstatic int stbi__parse_huffman_block(stbi__zbuf *a)\n{\n char *zout = a->zout;\n for(;;) {\n int z = stbi__zhuffman_decode(a, &a->z_length);\n if (z < 256) {\n if (z < 0) return stbi__err(\"bad huffman code\",\"Corrupt PNG\"); // error in huffman codes\n if (zout >= a->zout_end) {\n if (!stbi__zexpand(a, zout, 1)) return 0;\n zout = a->zout;\n }\n *zout++ = (char) z;\n } else {\n stbi_uc *p;\n int len,dist;\n if (z == 256) {\n a->zout = zout;\n if (a->hit_zeof_once && a->num_bits < 16) {\n // The first time we hit zeof, we inserted 16 extra zero bits into our bit\n // buffer so the decoder can just do its speculative decoding. But if we\n // actually consumed any of those bits (which is the case when num_bits < 16),\n // the stream actually read past the end so it is malformed.\n return stbi__err(\"unexpected end\",\"Corrupt PNG\");\n }\n return 1;\n }\n if (z >= 286) return stbi__err(\"bad huffman code\",\"Corrupt PNG\"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data\n z -= 257;\n len = stbi__zlength_base[z];\n if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]);\n z = stbi__zhuffman_decode(a, &a->z_distance);\n if (z < 0 || z >= 30) return stbi__err(\"bad huffman code\",\"Corrupt PNG\"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data\n dist = stbi__zdist_base[z];\n if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]);\n if (zout - a->zout_start < dist) return stbi__err(\"bad dist\",\"Corrupt PNG\");\n if (len > a->zout_end - zout) {\n if (!stbi__zexpand(a, zout, len)) return 0;\n zout = a->zout;\n }\n p = (stbi_uc *) (zout - dist);\n if (dist == 1) { // run of one byte; common in images.\n stbi_uc v = *p;\n if (len) { do *zout++ = v; while (--len); }\n } else {\n if (len) { do *zout++ = *p++; while (--len); }\n }\n }\n }\n}\n\nstatic int stbi__compute_huffman_codes(stbi__zbuf *a)\n{\n static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 };\n stbi__zhuffman z_codelength;\n stbi_uc lencodes[286+32+137];//padding for maximum single op\n stbi_uc codelength_sizes[19];\n int i,n;\n\n int hlit = stbi__zreceive(a,5) + 257;\n int hdist = stbi__zreceive(a,5) + 1;\n int hclen = stbi__zreceive(a,4) + 4;\n int ntot = hlit + hdist;\n\n memset(codelength_sizes, 0, sizeof(codelength_sizes));\n for (i=0; i < hclen; ++i) {\n int s = stbi__zreceive(a,3);\n codelength_sizes[length_dezigzag[i]] = (stbi_uc) s;\n }\n if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0;\n\n n = 0;\n while (n < ntot) {\n int c = stbi__zhuffman_decode(a, &z_codelength);\n if (c < 0 || c >= 19) return stbi__err(\"bad codelengths\", \"Corrupt PNG\");\n if (c < 16)\n lencodes[n++] = (stbi_uc) c;\n else {\n stbi_uc fill = 0;\n if (c == 16) {\n c = stbi__zreceive(a,2)+3;\n if (n == 0) return stbi__err(\"bad codelengths\", \"Corrupt PNG\");\n fill = lencodes[n-1];\n } else if (c == 17) {\n c = stbi__zreceive(a,3)+3;\n } else if (c == 18) {\n c = stbi__zreceive(a,7)+11;\n } else {\n return stbi__err(\"bad codelengths\", \"Corrupt PNG\");\n }\n if (ntot - n < c) return stbi__err(\"bad codelengths\", \"Corrupt PNG\");\n memset(lencodes+n, fill, c);\n n += c;\n }\n }\n if (n != ntot) return stbi__err(\"bad codelengths\",\"Corrupt PNG\");\n if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0;\n if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0;\n return 1;\n}\n\nstatic int stbi__parse_uncompressed_block(stbi__zbuf *a)\n{\n stbi_uc header[4];\n int len,nlen,k;\n if (a->num_bits & 7)\n stbi__zreceive(a, a->num_bits & 7); // discard\n // drain the bit-packed data into header\n k = 0;\n while (a->num_bits > 0) {\n header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check\n a->code_buffer >>= 8;\n a->num_bits -= 8;\n }\n if (a->num_bits < 0) return stbi__err(\"zlib corrupt\",\"Corrupt PNG\");\n // now fill header the normal way\n while (k < 4)\n header[k++] = stbi__zget8(a);\n len = header[1] * 256 + header[0];\n nlen = header[3] * 256 + header[2];\n if (nlen != (len ^ 0xffff)) return stbi__err(\"zlib corrupt\",\"Corrupt PNG\");\n if (a->zbuffer + len > a->zbuffer_end) return stbi__err(\"read past buffer\",\"Corrupt PNG\");\n if (a->zout + len > a->zout_end)\n if (!stbi__zexpand(a, a->zout, len)) return 0;\n memcpy(a->zout, a->zbuffer, len);\n a->zbuffer += len;\n a->zout += len;\n return 1;\n}\n\nstatic int stbi__parse_zlib_header(stbi__zbuf *a)\n{\n int cmf = stbi__zget8(a);\n int cm = cmf & 15;\n /* int cinfo = cmf >> 4; */\n int flg = stbi__zget8(a);\n if (stbi__zeof(a)) return stbi__err(\"bad zlib header\",\"Corrupt PNG\"); // zlib spec\n if ((cmf*256+flg) % 31 != 0) return stbi__err(\"bad zlib header\",\"Corrupt PNG\"); // zlib spec\n if (flg & 32) return stbi__err(\"no preset dict\",\"Corrupt PNG\"); // preset dictionary not allowed in png\n if (cm != 8) return stbi__err(\"bad compression\",\"Corrupt PNG\"); // DEFLATE required for png\n // window = 1 << (8 + cinfo)... but who cares, we fully buffer output\n return 1;\n}\n\nstatic const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] =\n{\n 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,\n 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,\n 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,\n 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,\n 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,\n 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,\n 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,\n 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,\n 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8\n};\nstatic const stbi_uc stbi__zdefault_distance[32] =\n{\n 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5\n};\n/*\nInit algorithm:\n{\n int i; // use <= to match clearly with spec\n for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8;\n for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9;\n for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7;\n for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8;\n\n for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5;\n}\n*/\n\nstatic int stbi__parse_zlib(stbi__zbuf *a, int parse_header)\n{\n int final, type;\n if (parse_header)\n if (!stbi__parse_zlib_header(a)) return 0;\n a->num_bits = 0;\n a->code_buffer = 0;\n a->hit_zeof_once = 0;\n do {\n final = stbi__zreceive(a,1);\n type = stbi__zreceive(a,2);\n if (type == 0) {\n if (!stbi__parse_uncompressed_block(a)) return 0;\n } else if (type == 3) {\n return 0;\n } else {\n if (type == 1) {\n // use fixed code lengths\n if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0;\n if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0;\n } else {\n if (!stbi__compute_huffman_codes(a)) return 0;\n }\n if (!stbi__parse_huffman_block(a)) return 0;\n }\n } while (!final);\n return 1;\n}\n\nstatic int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header)\n{\n a->zout_start = obuf;\n a->zout = obuf;\n a->zout_end = obuf + olen;\n a->z_expandable = exp;\n\n return stbi__parse_zlib(a, parse_header);\n}\n\nSTBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)\n{\n stbi__zbuf a;\n char *p = (char *) stbi__malloc(initial_size);\n if (p == NULL) return NULL;\n a.zbuffer = (stbi_uc *) buffer;\n a.zbuffer_end = (stbi_uc *) buffer + len;\n if (stbi__do_zlib(&a, p, initial_size, 1, 1)) {\n if (outlen) *outlen = (int) (a.zout - a.zout_start);\n return a.zout_start;\n } else {\n STBI_FREE(a.zout_start);\n return NULL;\n }\n}\n\nSTBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen)\n{\n return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen);\n}\n\nSTBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header)\n{\n stbi__zbuf a;\n char *p = (char *) stbi__malloc(initial_size);\n if (p == NULL) return NULL;\n a.zbuffer = (stbi_uc *) buffer;\n a.zbuffer_end = (stbi_uc *) buffer + len;\n if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) {\n if (outlen) *outlen = (int) (a.zout - a.zout_start);\n return a.zout_start;\n } else {\n STBI_FREE(a.zout_start);\n return NULL;\n }\n}\n\nSTBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen)\n{\n stbi__zbuf a;\n a.zbuffer = (stbi_uc *) ibuffer;\n a.zbuffer_end = (stbi_uc *) ibuffer + ilen;\n if (stbi__do_zlib(&a, obuffer, olen, 0, 1))\n return (int) (a.zout - a.zout_start);\n else\n return -1;\n}\n\nSTBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)\n{\n stbi__zbuf a;\n char *p = (char *) stbi__malloc(16384);\n if (p == NULL) return NULL;\n a.zbuffer = (stbi_uc *) buffer;\n a.zbuffer_end = (stbi_uc *) buffer+len;\n if (stbi__do_zlib(&a, p, 16384, 1, 0)) {\n if (outlen) *outlen = (int) (a.zout - a.zout_start);\n return a.zout_start;\n } else {\n STBI_FREE(a.zout_start);\n return NULL;\n }\n}\n\nSTBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen)\n{\n stbi__zbuf a;\n a.zbuffer = (stbi_uc *) ibuffer;\n a.zbuffer_end = (stbi_uc *) ibuffer + ilen;\n if (stbi__do_zlib(&a, obuffer, olen, 0, 0))\n return (int) (a.zout - a.zout_start);\n else\n return -1;\n}\n#endif\n\n// public domain \"baseline\" PNG decoder v0.10 Sean Barrett 2006-11-18\n// simple implementation\n// - only 8-bit samples\n// - no CRC checking\n// - allocates lots of intermediate memory\n// - avoids problem of streaming data between subsystems\n// - avoids explicit window management\n// performance\n// - uses stb_zlib, a PD zlib implementation with fast huffman decoding\n\n#ifndef STBI_NO_PNG\ntypedef struct\n{\n stbi__uint32 length;\n stbi__uint32 type;\n} stbi__pngchunk;\n\nstatic stbi__pngchunk stbi__get_chunk_header(stbi__context *s)\n{\n stbi__pngchunk c;\n c.length = stbi__get32be(s);\n c.type = stbi__get32be(s);\n return c;\n}\n\nstatic int stbi__check_png_header(stbi__context *s)\n{\n static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };\n int i;\n for (i=0; i < 8; ++i)\n if (stbi__get8(s) != png_sig[i]) return stbi__err(\"bad png sig\",\"Not a PNG\");\n return 1;\n}\n\ntypedef struct\n{\n stbi__context *s;\n stbi_uc *idata, *expanded, *out;\n int depth;\n} stbi__png;\n\n\nenum {\n STBI__F_none=0,\n STBI__F_sub=1,\n STBI__F_up=2,\n STBI__F_avg=3,\n STBI__F_paeth=4,\n // synthetic filter used for first scanline to avoid needing a dummy row of 0s\n STBI__F_avg_first\n};\n\nstatic stbi_uc first_row_filter[5] =\n{\n STBI__F_none,\n STBI__F_sub,\n STBI__F_none,\n STBI__F_avg_first,\n STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub\n};\n\nstatic int stbi__paeth(int a, int b, int c)\n{\n // This formulation looks very different from the reference in the PNG spec, but is\n // actually equivalent and has favorable data dependencies and admits straightforward\n // generation of branch-free code, which helps performance significantly.\n int thresh = c*3 - (a + b);\n int lo = a < b ? a : b;\n int hi = a < b ? b : a;\n int t0 = (hi <= thresh) ? lo : c;\n int t1 = (thresh <= lo) ? hi : t0;\n return t1;\n}\n\nstatic const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 };\n\n// adds an extra all-255 alpha channel\n// dest == src is legal\n// img_n must be 1 or 3\nstatic void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n)\n{\n int i;\n // must process data backwards since we allow dest==src\n if (img_n == 1) {\n for (i=x-1; i >= 0; --i) {\n dest[i*2+1] = 255;\n dest[i*2+0] = src[i];\n }\n } else {\n STBI_ASSERT(img_n == 3);\n for (i=x-1; i >= 0; --i) {\n dest[i*4+3] = 255;\n dest[i*4+2] = src[i*3+2];\n dest[i*4+1] = src[i*3+1];\n dest[i*4+0] = src[i*3+0];\n }\n }\n}\n\n// create the png data from post-deflated data\nstatic int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color)\n{\n int bytes = (depth == 16 ? 2 : 1);\n stbi__context *s = a->s;\n stbi__uint32 i,j,stride = x*out_n*bytes;\n stbi__uint32 img_len, img_width_bytes;\n stbi_uc *filter_buf;\n int all_ok = 1;\n int k;\n int img_n = s->img_n; // copy it into a local for later\n\n int output_bytes = out_n*bytes;\n int filter_bytes = img_n*bytes;\n int width = x;\n\n STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1);\n a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into\n if (!a->out) return stbi__err(\"outofmem\", \"Out of memory\");\n\n // note: error exits here don't need to clean up a->out individually,\n // stbi__do_png always does on error.\n if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err(\"too large\", \"Corrupt PNG\");\n img_width_bytes = (((img_n * x * depth) + 7) >> 3);\n if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err(\"too large\", \"Corrupt PNG\");\n img_len = (img_width_bytes + 1) * y;\n\n // we used to check for exact match between raw_len and img_len on non-interlaced PNGs,\n // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros),\n // so just check for raw_len < img_len always.\n if (raw_len < img_len) return stbi__err(\"not enough pixels\",\"Corrupt PNG\");\n\n // Allocate two scan lines worth of filter workspace buffer.\n filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0);\n if (!filter_buf) return stbi__err(\"outofmem\", \"Out of memory\");\n\n // Filtering for low-bit-depth images\n if (depth < 8) {\n filter_bytes = 1;\n width = img_width_bytes;\n }\n\n for (j=0; j < y; ++j) {\n // cur/prior filter buffers alternate\n stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes;\n stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes;\n stbi_uc *dest = a->out + stride*j;\n int nk = width * filter_bytes;\n int filter = *raw++;\n\n // check filter type\n if (filter > 4) {\n all_ok = stbi__err(\"invalid filter\",\"Corrupt PNG\");\n break;\n }\n\n // if first row, use special filter that doesn't sample previous row\n if (j == 0) filter = first_row_filter[filter];\n\n // perform actual filtering\n switch (filter) {\n case STBI__F_none:\n memcpy(cur, raw, nk);\n break;\n case STBI__F_sub:\n memcpy(cur, raw, filter_bytes);\n for (k = filter_bytes; k < nk; ++k)\n cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]);\n break;\n case STBI__F_up:\n for (k = 0; k < nk; ++k)\n cur[k] = STBI__BYTECAST(raw[k] + prior[k]);\n break;\n case STBI__F_avg:\n for (k = 0; k < filter_bytes; ++k)\n cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1));\n for (k = filter_bytes; k < nk; ++k)\n cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1));\n break;\n case STBI__F_paeth:\n for (k = 0; k < filter_bytes; ++k)\n cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0)\n for (k = filter_bytes; k < nk; ++k)\n cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes]));\n break;\n case STBI__F_avg_first:\n memcpy(cur, raw, filter_bytes);\n for (k = filter_bytes; k < nk; ++k)\n cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1));\n break;\n }\n\n raw += nk;\n\n // expand decoded bits in cur to dest, also adding an extra alpha channel if desired\n if (depth < 8) {\n stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range\n stbi_uc *in = cur;\n stbi_uc *out = dest;\n stbi_uc inb = 0;\n stbi__uint32 nsmp = x*img_n;\n\n // expand bits to bytes first\n if (depth == 4) {\n for (i=0; i < nsmp; ++i) {\n if ((i & 1) == 0) inb = *in++;\n *out++ = scale * (inb >> 4);\n inb <<= 4;\n }\n } else if (depth == 2) {\n for (i=0; i < nsmp; ++i) {\n if ((i & 3) == 0) inb = *in++;\n *out++ = scale * (inb >> 6);\n inb <<= 2;\n }\n } else {\n STBI_ASSERT(depth == 1);\n for (i=0; i < nsmp; ++i) {\n if ((i & 7) == 0) inb = *in++;\n *out++ = scale * (inb >> 7);\n inb <<= 1;\n }\n }\n\n // insert alpha=255 values if desired\n if (img_n != out_n)\n stbi__create_png_alpha_expand8(dest, dest, x, img_n);\n } else if (depth == 8) {\n if (img_n == out_n)\n memcpy(dest, cur, x*img_n);\n else\n stbi__create_png_alpha_expand8(dest, cur, x, img_n);\n } else if (depth == 16) {\n // convert the image data from big-endian to platform-native\n stbi__uint16 *dest16 = (stbi__uint16*)dest;\n stbi__uint32 nsmp = x*img_n;\n\n if (img_n == out_n) {\n for (i = 0; i < nsmp; ++i, ++dest16, cur += 2)\n *dest16 = (cur[0] << 8) | cur[1];\n } else {\n STBI_ASSERT(img_n+1 == out_n);\n if (img_n == 1) {\n for (i = 0; i < x; ++i, dest16 += 2, cur += 2) {\n dest16[0] = (cur[0] << 8) | cur[1];\n dest16[1] = 0xffff;\n }\n } else {\n STBI_ASSERT(img_n == 3);\n for (i = 0; i < x; ++i, dest16 += 4, cur += 6) {\n dest16[0] = (cur[0] << 8) | cur[1];\n dest16[1] = (cur[2] << 8) | cur[3];\n dest16[2] = (cur[4] << 8) | cur[5];\n dest16[3] = 0xffff;\n }\n }\n }\n }\n }\n\n STBI_FREE(filter_buf);\n if (!all_ok) return 0;\n\n return 1;\n}\n\nstatic int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced)\n{\n int bytes = (depth == 16 ? 2 : 1);\n int out_bytes = out_n * bytes;\n stbi_uc *final;\n int p;\n if (!interlaced)\n return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color);\n\n // de-interlacing\n final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0);\n if (!final) return stbi__err(\"outofmem\", \"Out of memory\");\n for (p=0; p < 7; ++p) {\n int xorig[] = { 0,4,0,2,0,1,0 };\n int yorig[] = { 0,0,4,0,2,0,1 };\n int xspc[] = { 8,8,4,4,2,2,1 };\n int yspc[] = { 8,8,8,4,4,2,2 };\n int i,j,x,y;\n // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1\n x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p];\n y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p];\n if (x && y) {\n stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y;\n if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) {\n STBI_FREE(final);\n return 0;\n }\n for (j=0; j < y; ++j) {\n for (i=0; i < x; ++i) {\n int out_y = j*yspc[p]+yorig[p];\n int out_x = i*xspc[p]+xorig[p];\n memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes,\n a->out + (j*x+i)*out_bytes, out_bytes);\n }\n }\n STBI_FREE(a->out);\n image_data += img_len;\n image_data_len -= img_len;\n }\n }\n a->out = final;\n\n return 1;\n}\n\nstatic int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)\n{\n stbi__context *s = z->s;\n stbi__uint32 i, pixel_count = s->img_x * s->img_y;\n stbi_uc *p = z->out;\n\n // compute color-based transparency, assuming we've\n // already got 255 as the alpha value in the output\n STBI_ASSERT(out_n == 2 || out_n == 4);\n\n if (out_n == 2) {\n for (i=0; i < pixel_count; ++i) {\n p[1] = (p[0] == tc[0] ? 0 : 255);\n p += 2;\n }\n } else {\n for (i=0; i < pixel_count; ++i) {\n if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])\n p[3] = 0;\n p += 4;\n }\n }\n return 1;\n}\n\nstatic int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)\n{\n stbi__context *s = z->s;\n stbi__uint32 i, pixel_count = s->img_x * s->img_y;\n stbi__uint16 *p = (stbi__uint16*) z->out;\n\n // compute color-based transparency, assuming we've\n // already got 65535 as the alpha value in the output\n STBI_ASSERT(out_n == 2 || out_n == 4);\n\n if (out_n == 2) {\n for (i = 0; i < pixel_count; ++i) {\n p[1] = (p[0] == tc[0] ? 0 : 65535);\n p += 2;\n }\n } else {\n for (i = 0; i < pixel_count; ++i) {\n if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2])\n p[3] = 0;\n p += 4;\n }\n }\n return 1;\n}\n\nstatic int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n)\n{\n stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y;\n stbi_uc *p, *temp_out, *orig = a->out;\n\n p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0);\n if (p == NULL) return stbi__err(\"outofmem\", \"Out of memory\");\n\n // between here and free(out) below, exitting would leak\n temp_out = p;\n\n if (pal_img_n == 3) {\n for (i=0; i < pixel_count; ++i) {\n int n = orig[i]*4;\n p[0] = palette[n ];\n p[1] = palette[n+1];\n p[2] = palette[n+2];\n p += 3;\n }\n } else {\n for (i=0; i < pixel_count; ++i) {\n int n = orig[i]*4;\n p[0] = palette[n ];\n p[1] = palette[n+1];\n p[2] = palette[n+2];\n p[3] = palette[n+3];\n p += 4;\n }\n }\n STBI_FREE(a->out);\n a->out = temp_out;\n\n STBI_NOTUSED(len);\n\n return 1;\n}\n\nstatic int stbi__unpremultiply_on_load_global = 0;\nstatic int stbi__de_iphone_flag_global = 0;\n\nSTBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)\n{\n stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply;\n}\n\nSTBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)\n{\n stbi__de_iphone_flag_global = flag_true_if_should_convert;\n}\n\n#ifndef STBI_THREAD_LOCAL\n#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global\n#define stbi__de_iphone_flag stbi__de_iphone_flag_global\n#else\nstatic STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set;\nstatic STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set;\n\nSTBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)\n{\n stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply;\n stbi__unpremultiply_on_load_set = 1;\n}\n\nSTBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)\n{\n stbi__de_iphone_flag_local = flag_true_if_should_convert;\n stbi__de_iphone_flag_set = 1;\n}\n\n#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \\\n ? stbi__unpremultiply_on_load_local \\\n : stbi__unpremultiply_on_load_global)\n#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \\\n ? stbi__de_iphone_flag_local \\\n : stbi__de_iphone_flag_global)\n#endif // STBI_THREAD_LOCAL\n\nstatic void stbi__de_iphone(stbi__png *z)\n{\n stbi__context *s = z->s;\n stbi__uint32 i, pixel_count = s->img_x * s->img_y;\n stbi_uc *p = z->out;\n\n if (s->img_out_n == 3) { // convert bgr to rgb\n for (i=0; i < pixel_count; ++i) {\n stbi_uc t = p[0];\n p[0] = p[2];\n p[2] = t;\n p += 3;\n }\n } else {\n STBI_ASSERT(s->img_out_n == 4);\n if (stbi__unpremultiply_on_load) {\n // convert bgr to rgb and unpremultiply\n for (i=0; i < pixel_count; ++i) {\n stbi_uc a = p[3];\n stbi_uc t = p[0];\n if (a) {\n stbi_uc half = a / 2;\n p[0] = (p[2] * 255 + half) / a;\n p[1] = (p[1] * 255 + half) / a;\n p[2] = ( t * 255 + half) / a;\n } else {\n p[0] = p[2];\n p[2] = t;\n }\n p += 4;\n }\n } else {\n // convert bgr to rgb\n for (i=0; i < pixel_count; ++i) {\n stbi_uc t = p[0];\n p[0] = p[2];\n p[2] = t;\n p += 4;\n }\n }\n }\n}\n\n#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d))\n\nstatic int stbi__parse_png_file(stbi__png *z, int scan, int req_comp)\n{\n stbi_uc palette[1024], pal_img_n=0;\n stbi_uc has_trans=0, tc[3]={0};\n stbi__uint16 tc16[3];\n stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0;\n int first=1,k,interlace=0, color=0, is_iphone=0;\n stbi__context *s = z->s;\n\n z->expanded = NULL;\n z->idata = NULL;\n z->out = NULL;\n\n if (!stbi__check_png_header(s)) return 0;\n\n if (scan == STBI__SCAN_type) return 1;\n\n for (;;) {\n stbi__pngchunk c = stbi__get_chunk_header(s);\n switch (c.type) {\n case STBI__PNG_TYPE('C','g','B','I'):\n is_iphone = 1;\n stbi__skip(s, c.length);\n break;\n case STBI__PNG_TYPE('I','H','D','R'): {\n int comp,filter;\n if (!first) return stbi__err(\"multiple IHDR\",\"Corrupt PNG\");\n first = 0;\n if (c.length != 13) return stbi__err(\"bad IHDR len\",\"Corrupt PNG\");\n s->img_x = stbi__get32be(s);\n s->img_y = stbi__get32be(s);\n if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err(\"too large\",\"Very large image (corrupt?)\");\n if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err(\"too large\",\"Very large image (corrupt?)\");\n z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err(\"1/2/4/8/16-bit only\",\"PNG not supported: 1/2/4/8/16-bit only\");\n color = stbi__get8(s); if (color > 6) return stbi__err(\"bad ctype\",\"Corrupt PNG\");\n if (color == 3 && z->depth == 16) return stbi__err(\"bad ctype\",\"Corrupt PNG\");\n if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err(\"bad ctype\",\"Corrupt PNG\");\n comp = stbi__get8(s); if (comp) return stbi__err(\"bad comp method\",\"Corrupt PNG\");\n filter= stbi__get8(s); if (filter) return stbi__err(\"bad filter method\",\"Corrupt PNG\");\n interlace = stbi__get8(s); if (interlace>1) return stbi__err(\"bad interlace method\",\"Corrupt PNG\");\n if (!s->img_x || !s->img_y) return stbi__err(\"0-pixel image\",\"Corrupt PNG\");\n if (!pal_img_n) {\n s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0);\n if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err(\"too large\", \"Image too large to decode\");\n } else {\n // if paletted, then pal_n is our final components, and\n // img_n is # components to decompress/filter.\n s->img_n = 1;\n if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err(\"too large\",\"Corrupt PNG\");\n }\n // even with SCAN_header, have to scan to see if we have a tRNS\n break;\n }\n\n case STBI__PNG_TYPE('P','L','T','E'): {\n if (first) return stbi__err(\"first not IHDR\", \"Corrupt PNG\");\n if (c.length > 256*3) return stbi__err(\"invalid PLTE\",\"Corrupt PNG\");\n pal_len = c.length / 3;\n if (pal_len * 3 != c.length) return stbi__err(\"invalid PLTE\",\"Corrupt PNG\");\n for (i=0; i < pal_len; ++i) {\n palette[i*4+0] = stbi__get8(s);\n palette[i*4+1] = stbi__get8(s);\n palette[i*4+2] = stbi__get8(s);\n palette[i*4+3] = 255;\n }\n break;\n }\n\n case STBI__PNG_TYPE('t','R','N','S'): {\n if (first) return stbi__err(\"first not IHDR\", \"Corrupt PNG\");\n if (z->idata) return stbi__err(\"tRNS after IDAT\",\"Corrupt PNG\");\n if (pal_img_n) {\n if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; }\n if (pal_len == 0) return stbi__err(\"tRNS before PLTE\",\"Corrupt PNG\");\n if (c.length > pal_len) return stbi__err(\"bad tRNS len\",\"Corrupt PNG\");\n pal_img_n = 4;\n for (i=0; i < c.length; ++i)\n palette[i*4+3] = stbi__get8(s);\n } else {\n if (!(s->img_n & 1)) return stbi__err(\"tRNS with alpha\",\"Corrupt PNG\");\n if (c.length != (stbi__uint32) s->img_n*2) return stbi__err(\"bad tRNS len\",\"Corrupt PNG\");\n has_trans = 1;\n // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now.\n if (scan == STBI__SCAN_header) { ++s->img_n; return 1; }\n if (z->depth == 16) {\n for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning\n tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is\n } else {\n for (k = 0; k < s->img_n && k < 3; ++k)\n tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger\n }\n }\n break;\n }\n\n case STBI__PNG_TYPE('I','D','A','T'): {\n if (first) return stbi__err(\"first not IHDR\", \"Corrupt PNG\");\n if (pal_img_n && !pal_len) return stbi__err(\"no PLTE\",\"Corrupt PNG\");\n if (scan == STBI__SCAN_header) {\n // header scan definitely stops at first IDAT\n if (pal_img_n)\n s->img_n = pal_img_n;\n return 1;\n }\n if (c.length > (1u << 30)) return stbi__err(\"IDAT size limit\", \"IDAT section larger than 2^30 bytes\");\n if ((int)(ioff + c.length) < (int)ioff) return 0;\n if (ioff + c.length > idata_limit) {\n stbi__uint32 idata_limit_old = idata_limit;\n stbi_uc *p;\n if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096;\n while (ioff + c.length > idata_limit)\n idata_limit *= 2;\n STBI_NOTUSED(idata_limit_old);\n p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err(\"outofmem\", \"Out of memory\");\n z->idata = p;\n }\n if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err(\"outofdata\",\"Corrupt PNG\");\n ioff += c.length;\n break;\n }\n\n case STBI__PNG_TYPE('I','E','N','D'): {\n stbi__uint32 raw_len, bpl;\n if (first) return stbi__err(\"first not IHDR\", \"Corrupt PNG\");\n if (scan != STBI__SCAN_load) return 1;\n if (z->idata == NULL) return stbi__err(\"no IDAT\",\"Corrupt PNG\");\n // initial guess for decoded data size to avoid unnecessary reallocs\n bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component\n raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */;\n z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone);\n if (z->expanded == NULL) return 0; // zlib should set error\n STBI_FREE(z->idata); z->idata = NULL;\n if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans)\n s->img_out_n = s->img_n+1;\n else\n s->img_out_n = s->img_n;\n if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0;\n if (has_trans) {\n if (z->depth == 16) {\n if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0;\n } else {\n if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0;\n }\n }\n if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2)\n stbi__de_iphone(z);\n if (pal_img_n) {\n // pal_img_n == 3 or 4\n s->img_n = pal_img_n; // record the actual colors we had\n s->img_out_n = pal_img_n;\n if (req_comp >= 3) s->img_out_n = req_comp;\n if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n))\n return 0;\n } else if (has_trans) {\n // non-paletted image with tRNS -> source image has (constant) alpha\n ++s->img_n;\n }\n STBI_FREE(z->expanded); z->expanded = NULL;\n // end of PNG chunk, read and skip CRC\n stbi__get32be(s);\n return 1;\n }\n\n default:\n // if critical, fail\n if (first) return stbi__err(\"first not IHDR\", \"Corrupt PNG\");\n if ((c.type & (1 << 29)) == 0) {\n #ifndef STBI_NO_FAILURE_STRINGS\n // not threadsafe\n static char invalid_chunk[] = \"XXXX PNG chunk not known\";\n invalid_chunk[0] = STBI__BYTECAST(c.type >> 24);\n invalid_chunk[1] = STBI__BYTECAST(c.type >> 16);\n invalid_chunk[2] = STBI__BYTECAST(c.type >> 8);\n invalid_chunk[3] = STBI__BYTECAST(c.type >> 0);\n #endif\n return stbi__err(invalid_chunk, \"PNG not supported: unknown PNG chunk type\");\n }\n stbi__skip(s, c.length);\n break;\n }\n // end of PNG chunk, read and skip CRC\n stbi__get32be(s);\n }\n}\n\nstatic void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri)\n{\n void *result=NULL;\n if (req_comp < 0 || req_comp > 4) return stbi__errpuc(\"bad req_comp\", \"Internal error\");\n if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) {\n if (p->depth <= 8)\n ri->bits_per_channel = 8;\n else if (p->depth == 16)\n ri->bits_per_channel = 16;\n else\n return stbi__errpuc(\"bad bits_per_channel\", \"PNG not supported: unsupported color depth\");\n result = p->out;\n p->out = NULL;\n if (req_comp && req_comp != p->s->img_out_n) {\n if (ri->bits_per_channel == 8)\n result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);\n else\n result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y);\n p->s->img_out_n = req_comp;\n if (result == NULL) return result;\n }\n *x = p->s->img_x;\n *y = p->s->img_y;\n if (n) *n = p->s->img_n;\n }\n STBI_FREE(p->out); p->out = NULL;\n STBI_FREE(p->expanded); p->expanded = NULL;\n STBI_FREE(p->idata); p->idata = NULL;\n\n return result;\n}\n\nstatic void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)\n{\n stbi__png p;\n p.s = s;\n return stbi__do_png(&p, x,y,comp,req_comp, ri);\n}\n\nstatic int stbi__png_test(stbi__context *s)\n{\n int r;\n r = stbi__check_png_header(s);\n stbi__rewind(s);\n return r;\n}\n\nstatic int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)\n{\n if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) {\n stbi__rewind( p->s );\n return 0;\n }\n if (x) *x = p->s->img_x;\n if (y) *y = p->s->img_y;\n if (comp) *comp = p->s->img_n;\n return 1;\n}\n\nstatic int stbi__png_info(stbi__context *s, int *x, int *y, int *comp)\n{\n stbi__png p;\n p.s = s;\n return stbi__png_info_raw(&p, x, y, comp);\n}\n\nstatic int stbi__png_is16(stbi__context *s)\n{\n stbi__png p;\n p.s = s;\n if (!stbi__png_info_raw(&p, NULL, NULL, NULL))\n\t return 0;\n if (p.depth != 16) {\n stbi__rewind(p.s);\n return 0;\n }\n return 1;\n}\n#endif\n\n// Microsoft/Windows BMP image\n\n#ifndef STBI_NO_BMP\nstatic int stbi__bmp_test_raw(stbi__context *s)\n{\n int r;\n int sz;\n if (stbi__get8(s) != 'B') return 0;\n if (stbi__get8(s) != 'M') return 0;\n stbi__get32le(s); // discard filesize\n stbi__get16le(s); // discard reserved\n stbi__get16le(s); // discard reserved\n stbi__get32le(s); // discard data offset\n sz = stbi__get32le(s);\n r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124);\n return r;\n}\n\nstatic int stbi__bmp_test(stbi__context *s)\n{\n int r = stbi__bmp_test_raw(s);\n stbi__rewind(s);\n return r;\n}\n\n\n// returns 0..31 for the highest set bit\nstatic int stbi__high_bit(unsigned int z)\n{\n int n=0;\n if (z == 0) return -1;\n if (z >= 0x10000) { n += 16; z >>= 16; }\n if (z >= 0x00100) { n += 8; z >>= 8; }\n if (z >= 0x00010) { n += 4; z >>= 4; }\n if (z >= 0x00004) { n += 2; z >>= 2; }\n if (z >= 0x00002) { n += 1;/* >>= 1;*/ }\n return n;\n}\n\nstatic int stbi__bitcount(unsigned int a)\n{\n a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2\n a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4\n a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits\n a = (a + (a >> 8)); // max 16 per 8 bits\n a = (a + (a >> 16)); // max 32 per 8 bits\n return a & 0xff;\n}\n\n// extract an arbitrarily-aligned N-bit value (N=bits)\n// from v, and then make it 8-bits long and fractionally\n// extend it to full full range.\nstatic int stbi__shiftsigned(unsigned int v, int shift, int bits)\n{\n static unsigned int mul_table[9] = {\n 0,\n 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,\n 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,\n };\n static unsigned int shift_table[9] = {\n 0, 0,0,1,0,2,4,6,0,\n };\n if (shift < 0)\n v <<= -shift;\n else\n v >>= shift;\n STBI_ASSERT(v < 256);\n v >>= (8-bits);\n STBI_ASSERT(bits >= 0 && bits <= 8);\n return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];\n}\n\ntypedef struct\n{\n int bpp, offset, hsz;\n unsigned int mr,mg,mb,ma, all_a;\n int extra_read;\n} stbi__bmp_data;\n\nstatic int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress)\n{\n // BI_BITFIELDS specifies masks explicitly, don't override\n if (compress == 3)\n return 1;\n\n if (compress == 0) {\n if (info->bpp == 16) {\n info->mr = 31u << 10;\n info->mg = 31u << 5;\n info->mb = 31u << 0;\n } else if (info->bpp == 32) {\n info->mr = 0xffu << 16;\n info->mg = 0xffu << 8;\n info->mb = 0xffu << 0;\n info->ma = 0xffu << 24;\n info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0\n } else {\n // otherwise, use defaults, which is all-0\n info->mr = info->mg = info->mb = info->ma = 0;\n }\n return 1;\n }\n return 0; // error\n}\n\nstatic void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)\n{\n int hsz;\n if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc(\"not BMP\", \"Corrupt BMP\");\n stbi__get32le(s); // discard filesize\n stbi__get16le(s); // discard reserved\n stbi__get16le(s); // discard reserved\n info->offset = stbi__get32le(s);\n info->hsz = hsz = stbi__get32le(s);\n info->mr = info->mg = info->mb = info->ma = 0;\n info->extra_read = 14;\n\n if (info->offset < 0) return stbi__errpuc(\"bad BMP\", \"bad BMP\");\n\n if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc(\"unknown BMP\", \"BMP type not supported: unknown\");\n if (hsz == 12) {\n s->img_x = stbi__get16le(s);\n s->img_y = stbi__get16le(s);\n } else {\n s->img_x = stbi__get32le(s);\n s->img_y = stbi__get32le(s);\n }\n if (stbi__get16le(s) != 1) return stbi__errpuc(\"bad BMP\", \"bad BMP\");\n info->bpp = stbi__get16le(s);\n if (hsz != 12) {\n int compress = stbi__get32le(s);\n if (compress == 1 || compress == 2) return stbi__errpuc(\"BMP RLE\", \"BMP type not supported: RLE\");\n if (compress >= 4) return stbi__errpuc(\"BMP JPEG/PNG\", \"BMP type not supported: unsupported compression\"); // this includes PNG/JPEG modes\n if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc(\"bad BMP\", \"bad BMP\"); // bitfields requires 16 or 32 bits/pixel\n stbi__get32le(s); // discard sizeof\n stbi__get32le(s); // discard hres\n stbi__get32le(s); // discard vres\n stbi__get32le(s); // discard colorsused\n stbi__get32le(s); // discard max important\n if (hsz == 40 || hsz == 56) {\n if (hsz == 56) {\n stbi__get32le(s);\n stbi__get32le(s);\n stbi__get32le(s);\n stbi__get32le(s);\n }\n if (info->bpp == 16 || info->bpp == 32) {\n if (compress == 0) {\n stbi__bmp_set_mask_defaults(info, compress);\n } else if (compress == 3) {\n info->mr = stbi__get32le(s);\n info->mg = stbi__get32le(s);\n info->mb = stbi__get32le(s);\n info->extra_read += 12;\n // not documented, but generated by photoshop and handled by mspaint\n if (info->mr == info->mg && info->mg == info->mb) {\n // ?!?!?\n return stbi__errpuc(\"bad BMP\", \"bad BMP\");\n }\n } else\n return stbi__errpuc(\"bad BMP\", \"bad BMP\");\n }\n } else {\n // V4/V5 header\n int i;\n if (hsz != 108 && hsz != 124)\n return stbi__errpuc(\"bad BMP\", \"bad BMP\");\n info->mr = stbi__get32le(s);\n info->mg = stbi__get32le(s);\n info->mb = stbi__get32le(s);\n info->ma = stbi__get32le(s);\n if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs\n stbi__bmp_set_mask_defaults(info, compress);\n stbi__get32le(s); // discard color space\n for (i=0; i < 12; ++i)\n stbi__get32le(s); // discard color space parameters\n if (hsz == 124) {\n stbi__get32le(s); // discard rendering intent\n stbi__get32le(s); // discard offset of profile data\n stbi__get32le(s); // discard size of profile data\n stbi__get32le(s); // discard reserved\n }\n }\n }\n return (void *) 1;\n}\n\n\nstatic void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)\n{\n stbi_uc *out;\n unsigned int mr=0,mg=0,mb=0,ma=0, all_a;\n stbi_uc pal[256][4];\n int psize=0,i,j,width;\n int flip_vertically, pad, target;\n stbi__bmp_data info;\n STBI_NOTUSED(ri);\n\n info.all_a = 255;\n if (stbi__bmp_parse_header(s, &info) == NULL)\n return NULL; // error code already set\n\n flip_vertically = ((int) s->img_y) > 0;\n s->img_y = abs((int) s->img_y);\n\n if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc(\"too large\",\"Very large image (corrupt?)\");\n if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc(\"too large\",\"Very large image (corrupt?)\");\n\n mr = info.mr;\n mg = info.mg;\n mb = info.mb;\n ma = info.ma;\n all_a = info.all_a;\n\n if (info.hsz == 12) {\n if (info.bpp < 24)\n psize = (info.offset - info.extra_read - 24) / 3;\n } else {\n if (info.bpp < 16)\n psize = (info.offset - info.extra_read - info.hsz) >> 2;\n }\n if (psize == 0) {\n // accept some number of extra bytes after the header, but if the offset points either to before\n // the header ends or implies a large amount of extra data, reject the file as malformed\n int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original);\n int header_limit = 1024; // max we actually read is below 256 bytes currently.\n int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size.\n if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) {\n return stbi__errpuc(\"bad header\", \"Corrupt BMP\");\n }\n // we established that bytes_read_so_far is positive and sensible.\n // the first half of this test rejects offsets that are either too small positives, or\n // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn\n // ensures the number computed in the second half of the test can't overflow.\n if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) {\n return stbi__errpuc(\"bad offset\", \"Corrupt BMP\");\n } else {\n stbi__skip(s, info.offset - bytes_read_so_far);\n }\n }\n\n if (info.bpp == 24 && ma == 0xff000000)\n s->img_n = 3;\n else\n s->img_n = ma ? 4 : 3;\n if (req_comp && req_comp >= 3) // we can directly decode 3 or 4\n target = req_comp;\n else\n target = s->img_n; // if they want monochrome, we'll post-convert\n\n // sanity-check size\n if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0))\n return stbi__errpuc(\"too large\", \"Corrupt BMP\");\n\n out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0);\n if (!out) return stbi__errpuc(\"outofmem\", \"Out of memory\");\n if (info.bpp < 16) {\n int z=0;\n if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc(\"invalid\", \"Corrupt BMP\"); }\n for (i=0; i < psize; ++i) {\n pal[i][2] = stbi__get8(s);\n pal[i][1] = stbi__get8(s);\n pal[i][0] = stbi__get8(s);\n if (info.hsz != 12) stbi__get8(s);\n pal[i][3] = 255;\n }\n stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4));\n if (info.bpp == 1) width = (s->img_x + 7) >> 3;\n else if (info.bpp == 4) width = (s->img_x + 1) >> 1;\n else if (info.bpp == 8) width = s->img_x;\n else { STBI_FREE(out); return stbi__errpuc(\"bad bpp\", \"Corrupt BMP\"); }\n pad = (-width)&3;\n if (info.bpp == 1) {\n for (j=0; j < (int) s->img_y; ++j) {\n int bit_offset = 7, v = stbi__get8(s);\n for (i=0; i < (int) s->img_x; ++i) {\n int color = (v>>bit_offset)&0x1;\n out[z++] = pal[color][0];\n out[z++] = pal[color][1];\n out[z++] = pal[color][2];\n if (target == 4) out[z++] = 255;\n if (i+1 == (int) s->img_x) break;\n if((--bit_offset) < 0) {\n bit_offset = 7;\n v = stbi__get8(s);\n }\n }\n stbi__skip(s, pad);\n }\n } else {\n for (j=0; j < (int) s->img_y; ++j) {\n for (i=0; i < (int) s->img_x; i += 2) {\n int v=stbi__get8(s),v2=0;\n if (info.bpp == 4) {\n v2 = v & 15;\n v >>= 4;\n }\n out[z++] = pal[v][0];\n out[z++] = pal[v][1];\n out[z++] = pal[v][2];\n if (target == 4) out[z++] = 255;\n if (i+1 == (int) s->img_x) break;\n v = (info.bpp == 8) ? stbi__get8(s) : v2;\n out[z++] = pal[v][0];\n out[z++] = pal[v][1];\n out[z++] = pal[v][2];\n if (target == 4) out[z++] = 255;\n }\n stbi__skip(s, pad);\n }\n }\n } else {\n int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0;\n int z = 0;\n int easy=0;\n stbi__skip(s, info.offset - info.extra_read - info.hsz);\n if (info.bpp == 24) width = 3 * s->img_x;\n else if (info.bpp == 16) width = 2*s->img_x;\n else /* bpp = 32 and pad = 0 */ width=0;\n pad = (-width) & 3;\n if (info.bpp == 24) {\n easy = 1;\n } else if (info.bpp == 32) {\n if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000)\n easy = 2;\n }\n if (!easy) {\n if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc(\"bad masks\", \"Corrupt BMP\"); }\n // right shift amt to put high bit in position #7\n rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr);\n gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg);\n bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb);\n ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma);\n if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc(\"bad masks\", \"Corrupt BMP\"); }\n }\n for (j=0; j < (int) s->img_y; ++j) {\n if (easy) {\n for (i=0; i < (int) s->img_x; ++i) {\n unsigned char a;\n out[z+2] = stbi__get8(s);\n out[z+1] = stbi__get8(s);\n out[z+0] = stbi__get8(s);\n z += 3;\n a = (easy == 2 ? stbi__get8(s) : 255);\n all_a |= a;\n if (target == 4) out[z++] = a;\n }\n } else {\n int bpp = info.bpp;\n for (i=0; i < (int) s->img_x; ++i) {\n stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s));\n unsigned int a;\n out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount));\n out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount));\n out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount));\n a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255);\n all_a |= a;\n if (target == 4) out[z++] = STBI__BYTECAST(a);\n }\n }\n stbi__skip(s, pad);\n }\n }\n\n // if alpha channel is all 0s, replace with all 255s\n if (target == 4 && all_a == 0)\n for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4)\n out[i] = 255;\n\n if (flip_vertically) {\n stbi_uc t;\n for (j=0; j < (int) s->img_y>>1; ++j) {\n stbi_uc *p1 = out + j *s->img_x*target;\n stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target;\n for (i=0; i < (int) s->img_x*target; ++i) {\n t = p1[i]; p1[i] = p2[i]; p2[i] = t;\n }\n }\n }\n\n if (req_comp && req_comp != target) {\n out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y);\n if (out == NULL) return out; // stbi__convert_format frees input on failure\n }\n\n *x = s->img_x;\n *y = s->img_y;\n if (comp) *comp = s->img_n;\n return out;\n}\n#endif\n\n// Targa Truevision - TGA\n// by Jonathan Dummer\n#ifndef STBI_NO_TGA\n// returns STBI_rgb or whatever, 0 on error\nstatic int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)\n{\n // only RGB or RGBA (incl. 16bit) or grey allowed\n if (is_rgb16) *is_rgb16 = 0;\n switch(bits_per_pixel) {\n case 8: return STBI_grey;\n case 16: if(is_grey) return STBI_grey_alpha;\n // fallthrough\n case 15: if(is_rgb16) *is_rgb16 = 1;\n return STBI_rgb;\n case 24: // fallthrough\n case 32: return bits_per_pixel/8;\n default: return 0;\n }\n}\n\nstatic int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)\n{\n int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;\n int sz, tga_colormap_type;\n stbi__get8(s); // discard Offset\n tga_colormap_type = stbi__get8(s); // colormap type\n if( tga_colormap_type > 1 ) {\n stbi__rewind(s);\n return 0; // only RGB or indexed allowed\n }\n tga_image_type = stbi__get8(s); // image type\n if ( tga_colormap_type == 1 ) { // colormapped (paletted) image\n if (tga_image_type != 1 && tga_image_type != 9) {\n stbi__rewind(s);\n return 0;\n }\n stbi__skip(s,4); // skip index of first colormap entry and number of entries\n sz = stbi__get8(s); // check bits per palette color entry\n if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) {\n stbi__rewind(s);\n return 0;\n }\n stbi__skip(s,4); // skip image x and y origin\n tga_colormap_bpp = sz;\n } else { // \"normal\" image w/o colormap - only RGB or grey allowed, +/- RLE\n if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) {\n stbi__rewind(s);\n return 0; // only RGB or grey allowed, +/- RLE\n }\n stbi__skip(s,9); // skip colormap specification and image x/y origin\n tga_colormap_bpp = 0;\n }\n tga_w = stbi__get16le(s);\n if( tga_w < 1 ) {\n stbi__rewind(s);\n return 0; // test width\n }\n tga_h = stbi__get16le(s);\n if( tga_h < 1 ) {\n stbi__rewind(s);\n return 0; // test height\n }\n tga_bits_per_pixel = stbi__get8(s); // bits per pixel\n stbi__get8(s); // ignore alpha bits\n if (tga_colormap_bpp != 0) {\n if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) {\n // when using a colormap, tga_bits_per_pixel is the size of the indexes\n // I don't think anything but 8 or 16bit indexes makes sense\n stbi__rewind(s);\n return 0;\n }\n tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL);\n } else {\n tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL);\n }\n if(!tga_comp) {\n stbi__rewind(s);\n return 0;\n }\n if (x) *x = tga_w;\n if (y) *y = tga_h;\n if (comp) *comp = tga_comp;\n return 1; // seems to have passed everything\n}\n\nstatic int stbi__tga_test(stbi__context *s)\n{\n int res = 0;\n int sz, tga_color_type;\n stbi__get8(s); // discard Offset\n tga_color_type = stbi__get8(s); // color type\n if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed\n sz = stbi__get8(s); // image type\n if ( tga_color_type == 1 ) { // colormapped (paletted) image\n if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9\n stbi__skip(s,4); // skip index of first colormap entry and number of entries\n sz = stbi__get8(s); // check bits per palette color entry\n if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;\n stbi__skip(s,4); // skip image x and y origin\n } else { // \"normal\" image w/o colormap\n if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE\n stbi__skip(s,9); // skip colormap specification and image x/y origin\n }\n if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width\n if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height\n sz = stbi__get8(s); // bits per pixel\n if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index\n if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd;\n\n res = 1; // if we got this far, everything's good and we can return 1 instead of 0\n\nerrorEnd:\n stbi__rewind(s);\n return res;\n}\n\n// read 16bit value and convert to 24bit RGB\nstatic void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out)\n{\n stbi__uint16 px = (stbi__uint16)stbi__get16le(s);\n stbi__uint16 fiveBitMask = 31;\n // we have 3 channels with 5bits each\n int r = (px >> 10) & fiveBitMask;\n int g = (px >> 5) & fiveBitMask;\n int b = px & fiveBitMask;\n // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later\n out[0] = (stbi_uc)((r * 255)/31);\n out[1] = (stbi_uc)((g * 255)/31);\n out[2] = (stbi_uc)((b * 255)/31);\n\n // some people claim that the most significant bit might be used for alpha\n // (possibly if an alpha-bit is set in the \"image descriptor byte\")\n // but that only made 16bit test images completely translucent..\n // so let's treat all 15 and 16bit TGAs as RGB with no alpha.\n}\n\nstatic void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)\n{\n // read in the TGA header stuff\n int tga_offset = stbi__get8(s);\n int tga_indexed = stbi__get8(s);\n int tga_image_type = stbi__get8(s);\n int tga_is_RLE = 0;\n int tga_palette_start = stbi__get16le(s);\n int tga_palette_len = stbi__get16le(s);\n int tga_palette_bits = stbi__get8(s);\n int tga_x_origin = stbi__get16le(s);\n int tga_y_origin = stbi__get16le(s);\n int tga_width = stbi__get16le(s);\n int tga_height = stbi__get16le(s);\n int tga_bits_per_pixel = stbi__get8(s);\n int tga_comp, tga_rgb16=0;\n int tga_inverted = stbi__get8(s);\n // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?)\n // image data\n unsigned char *tga_data;\n unsigned char *tga_palette = NULL;\n int i, j;\n unsigned char raw_data[4] = {0};\n int RLE_count = 0;\n int RLE_repeating = 0;\n int read_next_pixel = 1;\n STBI_NOTUSED(ri);\n STBI_NOTUSED(tga_x_origin); // @TODO\n STBI_NOTUSED(tga_y_origin); // @TODO\n\n if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc(\"too large\",\"Very large image (corrupt?)\");\n if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc(\"too large\",\"Very large image (corrupt?)\");\n\n // do a tiny bit of precessing\n if ( tga_image_type >= 8 )\n {\n tga_image_type -= 8;\n tga_is_RLE = 1;\n }\n tga_inverted = 1 - ((tga_inverted >> 5) & 1);\n\n // If I'm paletted, then I'll use the number of bits from the palette\n if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16);\n else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16);\n\n if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency\n return stbi__errpuc(\"bad format\", \"Can't find out TGA pixelformat\");\n\n // tga info\n *x = tga_width;\n *y = tga_height;\n if (comp) *comp = tga_comp;\n\n if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0))\n return stbi__errpuc(\"too large\", \"Corrupt TGA\");\n\n tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0);\n if (!tga_data) return stbi__errpuc(\"outofmem\", \"Out of memory\");\n\n // skip to the data's starting position (offset usually = 0)\n stbi__skip(s, tga_offset );\n\n if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) {\n for (i=0; i < tga_height; ++i) {\n int row = tga_inverted ? tga_height -i - 1 : i;\n stbi_uc *tga_row = tga_data + row*tga_width*tga_comp;\n stbi__getn(s, tga_row, tga_width * tga_comp);\n }\n } else {\n // do I need to load a palette?\n if ( tga_indexed)\n {\n if (tga_palette_len == 0) { /* you have to have at least one entry! */\n STBI_FREE(tga_data);\n return stbi__errpuc(\"bad palette\", \"Corrupt TGA\");\n }\n\n // any data to skip? (offset usually = 0)\n stbi__skip(s, tga_palette_start );\n // load the palette\n tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0);\n if (!tga_palette) {\n STBI_FREE(tga_data);\n return stbi__errpuc(\"outofmem\", \"Out of memory\");\n }\n if (tga_rgb16) {\n stbi_uc *pal_entry = tga_palette;\n STBI_ASSERT(tga_comp == STBI_rgb);\n for (i=0; i < tga_palette_len; ++i) {\n stbi__tga_read_rgb16(s, pal_entry);\n pal_entry += tga_comp;\n }\n } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) {\n STBI_FREE(tga_data);\n STBI_FREE(tga_palette);\n return stbi__errpuc(\"bad palette\", \"Corrupt TGA\");\n }\n }\n // load the data\n for (i=0; i < tga_width * tga_height; ++i)\n {\n // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk?\n if ( tga_is_RLE )\n {\n if ( RLE_count == 0 )\n {\n // yep, get the next byte as a RLE command\n int RLE_cmd = stbi__get8(s);\n RLE_count = 1 + (RLE_cmd & 127);\n RLE_repeating = RLE_cmd >> 7;\n read_next_pixel = 1;\n } else if ( !RLE_repeating )\n {\n read_next_pixel = 1;\n }\n } else\n {\n read_next_pixel = 1;\n }\n // OK, if I need to read a pixel, do it now\n if ( read_next_pixel )\n {\n // load however much data we did have\n if ( tga_indexed )\n {\n // read in index, then perform the lookup\n int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s);\n if ( pal_idx >= tga_palette_len ) {\n // invalid index\n pal_idx = 0;\n }\n pal_idx *= tga_comp;\n for (j = 0; j < tga_comp; ++j) {\n raw_data[j] = tga_palette[pal_idx+j];\n }\n } else if(tga_rgb16) {\n STBI_ASSERT(tga_comp == STBI_rgb);\n stbi__tga_read_rgb16(s, raw_data);\n } else {\n // read in the data raw\n for (j = 0; j < tga_comp; ++j) {\n raw_data[j] = stbi__get8(s);\n }\n }\n // clear the reading flag for the next pixel\n read_next_pixel = 0;\n } // end of reading a pixel\n\n // copy data\n for (j = 0; j < tga_comp; ++j)\n tga_data[i*tga_comp+j] = raw_data[j];\n\n // in case we're in RLE mode, keep counting down\n --RLE_count;\n }\n // do I need to invert the image?\n if ( tga_inverted )\n {\n for (j = 0; j*2 < tga_height; ++j)\n {\n int index1 = j * tga_width * tga_comp;\n int index2 = (tga_height - 1 - j) * tga_width * tga_comp;\n for (i = tga_width * tga_comp; i > 0; --i)\n {\n unsigned char temp = tga_data[index1];\n tga_data[index1] = tga_data[index2];\n tga_data[index2] = temp;\n ++index1;\n ++index2;\n }\n }\n }\n // clear my palette, if I had one\n if ( tga_palette != NULL )\n {\n STBI_FREE( tga_palette );\n }\n }\n\n // swap RGB - if the source data was RGB16, it already is in the right order\n if (tga_comp >= 3 && !tga_rgb16)\n {\n unsigned char* tga_pixel = tga_data;\n for (i=0; i < tga_width * tga_height; ++i)\n {\n unsigned char temp = tga_pixel[0];\n tga_pixel[0] = tga_pixel[2];\n tga_pixel[2] = temp;\n tga_pixel += tga_comp;\n }\n }\n\n // convert to target component count\n if (req_comp && req_comp != tga_comp)\n tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);\n\n // the things I do to get rid of an error message, and yet keep\n // Microsoft's C compilers happy... [8^(\n tga_palette_start = tga_palette_len = tga_palette_bits =\n tga_x_origin = tga_y_origin = 0;\n STBI_NOTUSED(tga_palette_start);\n // OK, done\n return tga_data;\n}\n#endif\n\n// *************************************************************************************************\n// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB\n\n#ifndef STBI_NO_PSD\nstatic int stbi__psd_test(stbi__context *s)\n{\n int r = (stbi__get32be(s) == 0x38425053);\n stbi__rewind(s);\n return r;\n}\n\nstatic int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount)\n{\n int count, nleft, len;\n\n count = 0;\n while ((nleft = pixelCount - count) > 0) {\n len = stbi__get8(s);\n if (len == 128) {\n // No-op.\n } else if (len < 128) {\n // Copy next len+1 bytes literally.\n len++;\n if (len > nleft) return 0; // corrupt data\n count += len;\n while (len) {\n *p = stbi__get8(s);\n p += 4;\n len--;\n }\n } else if (len > 128) {\n stbi_uc val;\n // Next -len+1 bytes in the dest are replicated from next source byte.\n // (Interpret len as a negative 8-bit int.)\n len = 257 - len;\n if (len > nleft) return 0; // corrupt data\n val = stbi__get8(s);\n count += len;\n while (len) {\n *p = val;\n p += 4;\n len--;\n }\n }\n }\n\n return 1;\n}\n\nstatic void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc)\n{\n int pixelCount;\n int channelCount, compression;\n int channel, i;\n int bitdepth;\n int w,h;\n stbi_uc *out;\n STBI_NOTUSED(ri);\n\n // Check identifier\n if (stbi__get32be(s) != 0x38425053) // \"8BPS\"\n return stbi__errpuc(\"not PSD\", \"Corrupt PSD image\");\n\n // Check file type version.\n if (stbi__get16be(s) != 1)\n return stbi__errpuc(\"wrong version\", \"Unsupported version of PSD image\");\n\n // Skip 6 reserved bytes.\n stbi__skip(s, 6 );\n\n // Read the number of channels (R, G, B, A, etc).\n channelCount = stbi__get16be(s);\n if (channelCount < 0 || channelCount > 16)\n return stbi__errpuc(\"wrong channel count\", \"Unsupported number of channels in PSD image\");\n\n // Read the rows and columns of the image.\n h = stbi__get32be(s);\n w = stbi__get32be(s);\n\n if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc(\"too large\",\"Very large image (corrupt?)\");\n if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc(\"too large\",\"Very large image (corrupt?)\");\n\n // Make sure the depth is 8 bits.\n bitdepth = stbi__get16be(s);\n if (bitdepth != 8 && bitdepth != 16)\n return stbi__errpuc(\"unsupported bit depth\", \"PSD bit depth is not 8 or 16 bit\");\n\n // Make sure the color mode is RGB.\n // Valid options are:\n // 0: Bitmap\n // 1: Grayscale\n // 2: Indexed color\n // 3: RGB color\n // 4: CMYK color\n // 7: Multichannel\n // 8: Duotone\n // 9: Lab color\n if (stbi__get16be(s) != 3)\n return stbi__errpuc(\"wrong color format\", \"PSD is not in RGB color format\");\n\n // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.)\n stbi__skip(s,stbi__get32be(s) );\n\n // Skip the image resources. (resolution, pen tool paths, etc)\n stbi__skip(s, stbi__get32be(s) );\n\n // Skip the reserved data.\n stbi__skip(s, stbi__get32be(s) );\n\n // Find out if the data is compressed.\n // Known values:\n // 0: no compression\n // 1: RLE compressed\n compression = stbi__get16be(s);\n if (compression > 1)\n return stbi__errpuc(\"bad compression\", \"PSD has an unknown compression format\");\n\n // Check size\n if (!stbi__mad3sizes_valid(4, w, h, 0))\n return stbi__errpuc(\"too large\", \"Corrupt PSD\");\n\n // Create the destination image.\n\n if (!compression && bitdepth == 16 && bpc == 16) {\n out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0);\n ri->bits_per_channel = 16;\n } else\n out = (stbi_uc *) stbi__malloc(4 * w*h);\n\n if (!out) return stbi__errpuc(\"outofmem\", \"Out of memory\");\n pixelCount = w*h;\n\n // Initialize the data to zero.\n //memset( out, 0, pixelCount * 4 );\n\n // Finally, the image data.\n if (compression) {\n // RLE as used by .PSD and .TIFF\n // Loop until you get the number of unpacked bytes you are expecting:\n // Read the next source byte into n.\n // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally.\n // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times.\n // Else if n is 128, noop.\n // Endloop\n\n // The RLE-compressed data is preceded by a 2-byte data count for each row in the data,\n // which we're going to just skip.\n stbi__skip(s, h * channelCount * 2 );\n\n // Read the RLE data by channel.\n for (channel = 0; channel < 4; channel++) {\n stbi_uc *p;\n\n p = out+channel;\n if (channel >= channelCount) {\n // Fill this channel with default data.\n for (i = 0; i < pixelCount; i++, p += 4)\n *p = (channel == 3 ? 255 : 0);\n } else {\n // Read the RLE data.\n if (!stbi__psd_decode_rle(s, p, pixelCount)) {\n STBI_FREE(out);\n return stbi__errpuc(\"corrupt\", \"bad RLE data\");\n }\n }\n }\n\n } else {\n // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...)\n // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image.\n\n // Read the data by channel.\n for (channel = 0; channel < 4; channel++) {\n if (channel >= channelCount) {\n // Fill this channel with default data.\n if (bitdepth == 16 && bpc == 16) {\n stbi__uint16 *q = ((stbi__uint16 *) out) + channel;\n stbi__uint16 val = channel == 3 ? 65535 : 0;\n for (i = 0; i < pixelCount; i++, q += 4)\n *q = val;\n } else {\n stbi_uc *p = out+channel;\n stbi_uc val = channel == 3 ? 255 : 0;\n for (i = 0; i < pixelCount; i++, p += 4)\n *p = val;\n }\n } else {\n if (ri->bits_per_channel == 16) { // output bpc\n stbi__uint16 *q = ((stbi__uint16 *) out) + channel;\n for (i = 0; i < pixelCount; i++, q += 4)\n *q = (stbi__uint16) stbi__get16be(s);\n } else {\n stbi_uc *p = out+channel;\n if (bitdepth == 16) { // input bpc\n for (i = 0; i < pixelCount; i++, p += 4)\n *p = (stbi_uc) (stbi__get16be(s) >> 8);\n } else {\n for (i = 0; i < pixelCount; i++, p += 4)\n *p = stbi__get8(s);\n }\n }\n }\n }\n }\n\n // remove weird white matte from PSD\n if (channelCount >= 4) {\n if (ri->bits_per_channel == 16) {\n for (i=0; i < w*h; ++i) {\n stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i;\n if (pixel[3] != 0 && pixel[3] != 65535) {\n float a = pixel[3] / 65535.0f;\n float ra = 1.0f / a;\n float inv_a = 65535.0f * (1 - ra);\n pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a);\n pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a);\n pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a);\n }\n }\n } else {\n for (i=0; i < w*h; ++i) {\n unsigned char *pixel = out + 4*i;\n if (pixel[3] != 0 && pixel[3] != 255) {\n float a = pixel[3] / 255.0f;\n float ra = 1.0f / a;\n float inv_a = 255.0f * (1 - ra);\n pixel[0] = (unsigned char) (pixel[0]*ra + inv_a);\n pixel[1] = (unsigned char) (pixel[1]*ra + inv_a);\n pixel[2] = (unsigned char) (pixel[2]*ra + inv_a);\n }\n }\n }\n }\n\n // convert to desired output format\n if (req_comp && req_comp != 4) {\n if (ri->bits_per_channel == 16)\n out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h);\n else\n out = stbi__convert_format(out, 4, req_comp, w, h);\n if (out == NULL) return out; // stbi__convert_format frees input on failure\n }\n\n if (comp) *comp = 4;\n *y = h;\n *x = w;\n\n return out;\n}\n#endif\n\n// *************************************************************************************************\n// Softimage PIC loader\n// by Tom Seddon\n//\n// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format\n// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/\n\n#ifndef STBI_NO_PIC\nstatic int stbi__pic_is4(stbi__context *s,const char *str)\n{\n int i;\n for (i=0; i<4; ++i)\n if (stbi__get8(s) != (stbi_uc)str[i])\n return 0;\n\n return 1;\n}\n\nstatic int stbi__pic_test_core(stbi__context *s)\n{\n int i;\n\n if (!stbi__pic_is4(s,\"\\x53\\x80\\xF6\\x34\"))\n return 0;\n\n for(i=0;i<84;++i)\n stbi__get8(s);\n\n if (!stbi__pic_is4(s,\"PICT\"))\n return 0;\n\n return 1;\n}\n\ntypedef struct\n{\n stbi_uc size,type,channel;\n} stbi__pic_packet;\n\nstatic stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)\n{\n int mask=0x80, i;\n\n for (i=0; i<4; ++i, mask>>=1) {\n if (channel & mask) {\n if (stbi__at_eof(s)) return stbi__errpuc(\"bad file\",\"PIC file too short\");\n dest[i]=stbi__get8(s);\n }\n }\n\n return dest;\n}\n\nstatic void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src)\n{\n int mask=0x80,i;\n\n for (i=0;i<4; ++i, mask>>=1)\n if (channel&mask)\n dest[i]=src[i];\n}\n\nstatic stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result)\n{\n int act_comp=0,num_packets=0,y,chained;\n stbi__pic_packet packets[10];\n\n // this will (should...) cater for even some bizarre stuff like having data\n // for the same channel in multiple packets.\n do {\n stbi__pic_packet *packet;\n\n if (num_packets==sizeof(packets)/sizeof(packets[0]))\n return stbi__errpuc(\"bad format\",\"too many packets\");\n\n packet = &packets[num_packets++];\n\n chained = stbi__get8(s);\n packet->size = stbi__get8(s);\n packet->type = stbi__get8(s);\n packet->channel = stbi__get8(s);\n\n act_comp |= packet->channel;\n\n if (stbi__at_eof(s)) return stbi__errpuc(\"bad file\",\"file too short (reading packets)\");\n if (packet->size != 8) return stbi__errpuc(\"bad format\",\"packet isn't 8bpp\");\n } while (chained);\n\n *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel?\n\n for(y=0; y<height; ++y) {\n int packet_idx;\n\n for(packet_idx=0; packet_idx < num_packets; ++packet_idx) {\n stbi__pic_packet *packet = &packets[packet_idx];\n stbi_uc *dest = result+y*width*4;\n\n switch (packet->type) {\n default:\n return stbi__errpuc(\"bad format\",\"packet has bad compression type\");\n\n case 0: {//uncompressed\n int x;\n\n for(x=0;x<width;++x, dest+=4)\n if (!stbi__readval(s,packet->channel,dest))\n return 0;\n break;\n }\n\n case 1://Pure RLE\n {\n int left=width, i;\n\n while (left>0) {\n stbi_uc count,value[4];\n\n count=stbi__get8(s);\n if (stbi__at_eof(s)) return stbi__errpuc(\"bad file\",\"file too short (pure read count)\");\n\n if (count > left)\n count = (stbi_uc) left;\n\n if (!stbi__readval(s,packet->channel,value)) return 0;\n\n for(i=0; i<count; ++i,dest+=4)\n stbi__copyval(packet->channel,dest,value);\n left -= count;\n }\n }\n break;\n\n case 2: {//Mixed RLE\n int left=width;\n while (left>0) {\n int count = stbi__get8(s), i;\n if (stbi__at_eof(s)) return stbi__errpuc(\"bad file\",\"file too short (mixed read count)\");\n\n if (count >= 128) { // Repeated\n stbi_uc value[4];\n\n if (count==128)\n count = stbi__get16be(s);\n else\n count -= 127;\n if (count > left)\n return stbi__errpuc(\"bad file\",\"scanline overrun\");\n\n if (!stbi__readval(s,packet->channel,value))\n return 0;\n\n for(i=0;i<count;++i, dest += 4)\n stbi__copyval(packet->channel,dest,value);\n } else { // Raw\n ++count;\n if (count>left) return stbi__errpuc(\"bad file\",\"scanline overrun\");\n\n for(i=0;i<count;++i, dest+=4)\n if (!stbi__readval(s,packet->channel,dest))\n return 0;\n }\n left-=count;\n }\n break;\n }\n }\n }\n }\n\n return result;\n}\n\nstatic void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri)\n{\n stbi_uc *result;\n int i, x,y, internal_comp;\n STBI_NOTUSED(ri);\n\n if (!comp) comp = &internal_comp;\n\n for (i=0; i<92; ++i)\n stbi__get8(s);\n\n x = stbi__get16be(s);\n y = stbi__get16be(s);\n\n if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc(\"too large\",\"Very large image (corrupt?)\");\n if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc(\"too large\",\"Very large image (corrupt?)\");\n\n if (stbi__at_eof(s)) return stbi__errpuc(\"bad file\",\"file too short (pic header)\");\n if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc(\"too large\", \"PIC image too large to decode\");\n\n stbi__get32be(s); //skip `ratio'\n stbi__get16be(s); //skip `fields'\n stbi__get16be(s); //skip `pad'\n\n // intermediate buffer is RGBA\n result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0);\n if (!result) return stbi__errpuc(\"outofmem\", \"Out of memory\");\n memset(result, 0xff, x*y*4);\n\n if (!stbi__pic_load_core(s,x,y,comp, result)) {\n STBI_FREE(result);\n result=0;\n }\n *px = x;\n *py = y;\n if (req_comp == 0) req_comp = *comp;\n result=stbi__convert_format(result,4,req_comp,x,y);\n\n return result;\n}\n\nstatic int stbi__pic_test(stbi__context *s)\n{\n int r = stbi__pic_test_core(s);\n stbi__rewind(s);\n return r;\n}\n#endif\n\n// *************************************************************************************************\n// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb\n\n#ifndef STBI_NO_GIF\ntypedef struct\n{\n stbi__int16 prefix;\n stbi_uc first;\n stbi_uc suffix;\n} stbi__gif_lzw;\n\ntypedef struct\n{\n int w,h;\n stbi_uc *out; // output buffer (always 4 components)\n stbi_uc *background; // The current \"background\" as far as a gif is concerned\n stbi_uc *history;\n int flags, bgindex, ratio, transparent, eflags;\n stbi_uc pal[256][4];\n stbi_uc lpal[256][4];\n stbi__gif_lzw codes[8192];\n stbi_uc *color_table;\n int parse, step;\n int lflags;\n int start_x, start_y;\n int max_x, max_y;\n int cur_x, cur_y;\n int line_size;\n int delay;\n} stbi__gif;\n\nstatic int stbi__gif_test_raw(stbi__context *s)\n{\n int sz;\n if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0;\n sz = stbi__get8(s);\n if (sz != '9' && sz != '7') return 0;\n if (stbi__get8(s) != 'a') return 0;\n return 1;\n}\n\nstatic int stbi__gif_test(stbi__context *s)\n{\n int r = stbi__gif_test_raw(s);\n stbi__rewind(s);\n return r;\n}\n\nstatic void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)\n{\n int i;\n for (i=0; i < num_entries; ++i) {\n pal[i][2] = stbi__get8(s);\n pal[i][1] = stbi__get8(s);\n pal[i][0] = stbi__get8(s);\n pal[i][3] = transp == i ? 0 : 255;\n }\n}\n\nstatic int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)\n{\n stbi_uc version;\n if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')\n return stbi__err(\"not GIF\", \"Corrupt GIF\");\n\n version = stbi__get8(s);\n if (version != '7' && version != '9') return stbi__err(\"not GIF\", \"Corrupt GIF\");\n if (stbi__get8(s) != 'a') return stbi__err(\"not GIF\", \"Corrupt GIF\");\n\n stbi__g_failure_reason = \"\";\n g->w = stbi__get16le(s);\n g->h = stbi__get16le(s);\n g->flags = stbi__get8(s);\n g->bgindex = stbi__get8(s);\n g->ratio = stbi__get8(s);\n g->transparent = -1;\n\n if (g->w > STBI_MAX_DIMENSIONS) return stbi__err(\"too large\",\"Very large image (corrupt?)\");\n if (g->h > STBI_MAX_DIMENSIONS) return stbi__err(\"too large\",\"Very large image (corrupt?)\");\n\n if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments\n\n if (is_info) return 1;\n\n if (g->flags & 0x80)\n stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1);\n\n return 1;\n}\n\nstatic int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp)\n{\n stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif));\n if (!g) return stbi__err(\"outofmem\", \"Out of memory\");\n if (!stbi__gif_header(s, g, comp, 1)) {\n STBI_FREE(g);\n stbi__rewind( s );\n return 0;\n }\n if (x) *x = g->w;\n if (y) *y = g->h;\n STBI_FREE(g);\n return 1;\n}\n\nstatic void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)\n{\n stbi_uc *p, *c;\n int idx;\n\n // recurse to decode the prefixes, since the linked-list is backwards,\n // and working backwards through an interleaved image would be nasty\n if (g->codes[code].prefix >= 0)\n stbi__out_gif_code(g, g->codes[code].prefix);\n\n if (g->cur_y >= g->max_y) return;\n\n idx = g->cur_x + g->cur_y;\n p = &g->out[idx];\n g->history[idx / 4] = 1;\n\n c = &g->color_table[g->codes[code].suffix * 4];\n if (c[3] > 128) { // don't render transparent pixels;\n p[0] = c[2];\n p[1] = c[1];\n p[2] = c[0];\n p[3] = c[3];\n }\n g->cur_x += 4;\n\n if (g->cur_x >= g->max_x) {\n g->cur_x = g->start_x;\n g->cur_y += g->step;\n\n while (g->cur_y >= g->max_y && g->parse > 0) {\n g->step = (1 << g->parse) * g->line_size;\n g->cur_y = g->start_y + (g->step >> 1);\n --g->parse;\n }\n }\n}\n\nstatic stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g)\n{\n stbi_uc lzw_cs;\n stbi__int32 len, init_code;\n stbi__uint32 first;\n stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear;\n stbi__gif_lzw *p;\n\n lzw_cs = stbi__get8(s);\n if (lzw_cs > 12) return NULL;\n clear = 1 << lzw_cs;\n first = 1;\n codesize = lzw_cs + 1;\n codemask = (1 << codesize) - 1;\n bits = 0;\n valid_bits = 0;\n for (init_code = 0; init_code < clear; init_code++) {\n g->codes[init_code].prefix = -1;\n g->codes[init_code].first = (stbi_uc) init_code;\n g->codes[init_code].suffix = (stbi_uc) init_code;\n }\n\n // support no starting clear code\n avail = clear+2;\n oldcode = -1;\n\n len = 0;\n for(;;) {\n if (valid_bits < codesize) {\n if (len == 0) {\n len = stbi__get8(s); // start new block\n if (len == 0)\n return g->out;\n }\n --len;\n bits |= (stbi__int32) stbi__get8(s) << valid_bits;\n valid_bits += 8;\n } else {\n stbi__int32 code = bits & codemask;\n bits >>= codesize;\n valid_bits -= codesize;\n // @OPTIMIZE: is there some way we can accelerate the non-clear path?\n if (code == clear) { // clear code\n codesize = lzw_cs + 1;\n codemask = (1 << codesize) - 1;\n avail = clear + 2;\n oldcode = -1;\n first = 0;\n } else if (code == clear + 1) { // end of stream code\n stbi__skip(s, len);\n while ((len = stbi__get8(s)) > 0)\n stbi__skip(s,len);\n return g->out;\n } else if (code <= avail) {\n if (first) {\n return stbi__errpuc(\"no clear code\", \"Corrupt GIF\");\n }\n\n if (oldcode >= 0) {\n p = &g->codes[avail++];\n if (avail > 8192) {\n return stbi__errpuc(\"too many codes\", \"Corrupt GIF\");\n }\n\n p->prefix = (stbi__int16) oldcode;\n p->first = g->codes[oldcode].first;\n p->suffix = (code == avail) ? p->first : g->codes[code].first;\n } else if (code == avail)\n return stbi__errpuc(\"illegal code in raster\", \"Corrupt GIF\");\n\n stbi__out_gif_code(g, (stbi__uint16) code);\n\n if ((avail & codemask) == 0 && avail <= 0x0FFF) {\n codesize++;\n codemask = (1 << codesize) - 1;\n }\n\n oldcode = code;\n } else {\n return stbi__errpuc(\"illegal code in raster\", \"Corrupt GIF\");\n }\n }\n }\n}\n\n// this function is designed to support animated gifs, although stb_image doesn't support it\n// two back is the image from two frames ago, used for a very specific disposal format\nstatic stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)\n{\n int dispose;\n int first_frame;\n int pi;\n int pcount;\n STBI_NOTUSED(req_comp);\n\n // on first frame, any non-written pixels get the background colour (non-transparent)\n first_frame = 0;\n if (g->out == 0) {\n if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header\n if (!stbi__mad3sizes_valid(4, g->w, g->h, 0))\n return stbi__errpuc(\"too large\", \"GIF image is too large\");\n pcount = g->w * g->h;\n g->out = (stbi_uc *) stbi__malloc(4 * pcount);\n g->background = (stbi_uc *) stbi__malloc(4 * pcount);\n g->history = (stbi_uc *) stbi__malloc(pcount);\n if (!g->out || !g->background || !g->history)\n return stbi__errpuc(\"outofmem\", \"Out of memory\");\n\n // image is treated as \"transparent\" at the start - ie, nothing overwrites the current background;\n // background colour is only used for pixels that are not rendered first frame, after that \"background\"\n // color refers to the color that was there the previous frame.\n memset(g->out, 0x00, 4 * pcount);\n memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent)\n memset(g->history, 0x00, pcount); // pixels that were affected previous frame\n first_frame = 1;\n } else {\n // second frame - how do we dispose of the previous one?\n dispose = (g->eflags & 0x1C) >> 2;\n pcount = g->w * g->h;\n\n if ((dispose == 3) && (two_back == 0)) {\n dispose = 2; // if I don't have an image to revert back to, default to the old background\n }\n\n if (dispose == 3) { // use previous graphic\n for (pi = 0; pi < pcount; ++pi) {\n if (g->history[pi]) {\n memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 );\n }\n }\n } else if (dispose == 2) {\n // restore what was changed last frame to background before that frame;\n for (pi = 0; pi < pcount; ++pi) {\n if (g->history[pi]) {\n memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 );\n }\n }\n } else {\n // This is a non-disposal case eithe way, so just\n // leave the pixels as is, and they will become the new background\n // 1: do not dispose\n // 0: not specified.\n }\n\n // background is what out is after the undoing of the previou frame;\n memcpy( g->background, g->out, 4 * g->w * g->h );\n }\n\n // clear my history;\n memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame\n\n for (;;) {\n int tag = stbi__get8(s);\n switch (tag) {\n case 0x2C: /* Image Descriptor */\n {\n stbi__int32 x, y, w, h;\n stbi_uc *o;\n\n x = stbi__get16le(s);\n y = stbi__get16le(s);\n w = stbi__get16le(s);\n h = stbi__get16le(s);\n if (((x + w) > (g->w)) || ((y + h) > (g->h)))\n return stbi__errpuc(\"bad Image Descriptor\", \"Corrupt GIF\");\n\n g->line_size = g->w * 4;\n g->start_x = x * 4;\n g->start_y = y * g->line_size;\n g->max_x = g->start_x + w * 4;\n g->max_y = g->start_y + h * g->line_size;\n g->cur_x = g->start_x;\n g->cur_y = g->start_y;\n\n // if the width of the specified rectangle is 0, that means\n // we may not see *any* pixels or the image is malformed;\n // to make sure this is caught, move the current y down to\n // max_y (which is what out_gif_code checks).\n if (w == 0)\n g->cur_y = g->max_y;\n\n g->lflags = stbi__get8(s);\n\n if (g->lflags & 0x40) {\n g->step = 8 * g->line_size; // first interlaced spacing\n g->parse = 3;\n } else {\n g->step = g->line_size;\n g->parse = 0;\n }\n\n if (g->lflags & 0x80) {\n stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1);\n g->color_table = (stbi_uc *) g->lpal;\n } else if (g->flags & 0x80) {\n g->color_table = (stbi_uc *) g->pal;\n } else\n return stbi__errpuc(\"missing color table\", \"Corrupt GIF\");\n\n o = stbi__process_gif_raster(s, g);\n if (!o) return NULL;\n\n // if this was the first frame,\n pcount = g->w * g->h;\n if (first_frame && (g->bgindex > 0)) {\n // if first frame, any pixel not drawn to gets the background color\n for (pi = 0; pi < pcount; ++pi) {\n if (g->history[pi] == 0) {\n g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be;\n memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 );\n }\n }\n }\n\n return o;\n }\n\n case 0x21: // Comment Extension.\n {\n int len;\n int ext = stbi__get8(s);\n if (ext == 0xF9) { // Graphic Control Extension.\n len = stbi__get8(s);\n if (len == 4) {\n g->eflags = stbi__get8(s);\n g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths.\n\n // unset old transparent\n if (g->transparent >= 0) {\n g->pal[g->transparent][3] = 255;\n }\n if (g->eflags & 0x01) {\n g->transparent = stbi__get8(s);\n if (g->transparent >= 0) {\n g->pal[g->transparent][3] = 0;\n }\n } else {\n // don't need transparent\n stbi__skip(s, 1);\n g->transparent = -1;\n }\n } else {\n stbi__skip(s, len);\n break;\n }\n }\n while ((len = stbi__get8(s)) != 0) {\n stbi__skip(s, len);\n }\n break;\n }\n\n case 0x3B: // gif stream termination code\n return (stbi_uc *) s; // using '1' causes warning on some compilers\n\n default:\n return stbi__errpuc(\"unknown code\", \"Corrupt GIF\");\n }\n }\n}\n\nstatic void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)\n{\n STBI_FREE(g->out);\n STBI_FREE(g->history);\n STBI_FREE(g->background);\n\n if (out) STBI_FREE(out);\n if (delays && *delays) STBI_FREE(*delays);\n return stbi__errpuc(\"outofmem\", \"Out of memory\");\n}\n\nstatic void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp)\n{\n if (stbi__gif_test(s)) {\n int layers = 0;\n stbi_uc *u = 0;\n stbi_uc *out = 0;\n stbi_uc *two_back = 0;\n stbi__gif g;\n int stride;\n int out_size = 0;\n int delays_size = 0;\n\n STBI_NOTUSED(out_size);\n STBI_NOTUSED(delays_size);\n\n memset(&g, 0, sizeof(g));\n if (delays) {\n *delays = 0;\n }\n\n do {\n u = stbi__gif_load_next(s, &g, comp, req_comp, two_back);\n if (u == (stbi_uc *) s) u = 0; // end of animated gif marker\n\n if (u) {\n *x = g.w;\n *y = g.h;\n ++layers;\n stride = g.w * g.h * 4;\n\n if (out) {\n void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride );\n if (!tmp)\n return stbi__load_gif_main_outofmem(&g, out, delays);\n else {\n out = (stbi_uc*) tmp;\n out_size = layers * stride;\n }\n\n if (delays) {\n int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers );\n if (!new_delays)\n return stbi__load_gif_main_outofmem(&g, out, delays);\n *delays = new_delays;\n delays_size = layers * sizeof(int);\n }\n } else {\n out = (stbi_uc*)stbi__malloc( layers * stride );\n if (!out)\n return stbi__load_gif_main_outofmem(&g, out, delays);\n out_size = layers * stride;\n if (delays) {\n *delays = (int*) stbi__malloc( layers * sizeof(int) );\n if (!*delays)\n return stbi__load_gif_main_outofmem(&g, out, delays);\n delays_size = layers * sizeof(int);\n }\n }\n memcpy( out + ((layers - 1) * stride), u, stride );\n if (layers >= 2) {\n two_back = out - 2 * stride;\n }\n\n if (delays) {\n (*delays)[layers - 1U] = g.delay;\n }\n }\n } while (u != 0);\n\n // free temp buffer;\n STBI_FREE(g.out);\n STBI_FREE(g.history);\n STBI_FREE(g.background);\n\n // do the final conversion after loading everything;\n if (req_comp && req_comp != 4)\n out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h);\n\n *z = layers;\n return out;\n } else {\n return stbi__errpuc(\"not GIF\", \"Image was not as a gif type.\");\n }\n}\n\nstatic void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)\n{\n stbi_uc *u = 0;\n stbi__gif g;\n memset(&g, 0, sizeof(g));\n STBI_NOTUSED(ri);\n\n u = stbi__gif_load_next(s, &g, comp, req_comp, 0);\n if (u == (stbi_uc *) s) u = 0; // end of animated gif marker\n if (u) {\n *x = g.w;\n *y = g.h;\n\n // moved conversion to after successful load so that the same\n // can be done for multiple frames.\n if (req_comp && req_comp != 4)\n u = stbi__convert_format(u, 4, req_comp, g.w, g.h);\n } else if (g.out) {\n // if there was an error and we allocated an image buffer, free it!\n STBI_FREE(g.out);\n }\n\n // free buffers needed for multiple frame loading;\n STBI_FREE(g.history);\n STBI_FREE(g.background);\n\n return u;\n}\n\nstatic int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp)\n{\n return stbi__gif_info_raw(s,x,y,comp);\n}\n#endif\n\n// *************************************************************************************************\n// Radiance RGBE HDR loader\n// originally by Nicolas Schulz\n#ifndef STBI_NO_HDR\nstatic int stbi__hdr_test_core(stbi__context *s, const char *signature)\n{\n int i;\n for (i=0; signature[i]; ++i)\n if (stbi__get8(s) != signature[i])\n return 0;\n stbi__rewind(s);\n return 1;\n}\n\nstatic int stbi__hdr_test(stbi__context* s)\n{\n int r = stbi__hdr_test_core(s, \"#?RADIANCE\\n\");\n stbi__rewind(s);\n if(!r) {\n r = stbi__hdr_test_core(s, \"#?RGBE\\n\");\n stbi__rewind(s);\n }\n return r;\n}\n\n#define STBI__HDR_BUFLEN 1024\nstatic char *stbi__hdr_gettoken(stbi__context *z, char *buffer)\n{\n int len=0;\n char c = '\\0';\n\n c = (char) stbi__get8(z);\n\n while (!stbi__at_eof(z) && c != '\\n') {\n buffer[len++] = c;\n if (len == STBI__HDR_BUFLEN-1) {\n // flush to end of line\n while (!stbi__at_eof(z) && stbi__get8(z) != '\\n')\n ;\n break;\n }\n c = (char) stbi__get8(z);\n }\n\n buffer[len] = 0;\n return buffer;\n}\n\nstatic void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)\n{\n if ( input[3] != 0 ) {\n float f1;\n // Exponent\n f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));\n if (req_comp <= 2)\n output[0] = (input[0] + input[1] + input[2]) * f1 / 3;\n else {\n output[0] = input[0] * f1;\n output[1] = input[1] * f1;\n output[2] = input[2] * f1;\n }\n if (req_comp == 2) output[1] = 1;\n if (req_comp == 4) output[3] = 1;\n } else {\n switch (req_comp) {\n case 4: output[3] = 1; /* fallthrough */\n case 3: output[0] = output[1] = output[2] = 0;\n break;\n case 2: output[1] = 1; /* fallthrough */\n case 1: output[0] = 0;\n break;\n }\n }\n}\n\nstatic float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)\n{\n char buffer[STBI__HDR_BUFLEN];\n char *token;\n int valid = 0;\n int width, height;\n stbi_uc *scanline;\n float *hdr_data;\n int len;\n unsigned char count, value;\n int i, j, k, c1,c2, z;\n const char *headerToken;\n STBI_NOTUSED(ri);\n\n // Check identifier\n headerToken = stbi__hdr_gettoken(s,buffer);\n if (strcmp(headerToken, \"#?RADIANCE\") != 0 && strcmp(headerToken, \"#?RGBE\") != 0)\n return stbi__errpf(\"not HDR\", \"Corrupt HDR image\");\n\n // Parse header\n for(;;) {\n token = stbi__hdr_gettoken(s,buffer);\n if (token[0] == 0) break;\n if (strcmp(token, \"FORMAT=32-bit_rle_rgbe\") == 0) valid = 1;\n }\n\n if (!valid) return stbi__errpf(\"unsupported format\", \"Unsupported HDR format\");\n\n // Parse width and height\n // can't use sscanf() if we're not using stdio!\n token = stbi__hdr_gettoken(s,buffer);\n if (strncmp(token, \"-Y \", 3)) return stbi__errpf(\"unsupported data layout\", \"Unsupported HDR format\");\n token += 3;\n height = (int) strtol(token, &token, 10);\n while (*token == ' ') ++token;\n if (strncmp(token, \"+X \", 3)) return stbi__errpf(\"unsupported data layout\", \"Unsupported HDR format\");\n token += 3;\n width = (int) strtol(token, NULL, 10);\n\n if (height > STBI_MAX_DIMENSIONS) return stbi__errpf(\"too large\",\"Very large image (corrupt?)\");\n if (width > STBI_MAX_DIMENSIONS) return stbi__errpf(\"too large\",\"Very large image (corrupt?)\");\n\n *x = width;\n *y = height;\n\n if (comp) *comp = 3;\n if (req_comp == 0) req_comp = 3;\n\n if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0))\n return stbi__errpf(\"too large\", \"HDR image is too large\");\n\n // Read data\n hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0);\n if (!hdr_data)\n return stbi__errpf(\"outofmem\", \"Out of memory\");\n\n // Load image data\n // image data is stored as some number of sca\n if ( width < 8 || width >= 32768) {\n // Read flat data\n for (j=0; j < height; ++j) {\n for (i=0; i < width; ++i) {\n stbi_uc rgbe[4];\n main_decode_loop:\n stbi__getn(s, rgbe, 4);\n stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp);\n }\n }\n } else {\n // Read RLE-encoded data\n scanline = NULL;\n\n for (j = 0; j < height; ++j) {\n c1 = stbi__get8(s);\n c2 = stbi__get8(s);\n len = stbi__get8(s);\n if (c1 != 2 || c2 != 2 || (len & 0x80)) {\n // not run-length encoded, so we have to actually use THIS data as a decoded\n // pixel (note this can't be a valid pixel--one of RGB must be >= 128)\n stbi_uc rgbe[4];\n rgbe[0] = (stbi_uc) c1;\n rgbe[1] = (stbi_uc) c2;\n rgbe[2] = (stbi_uc) len;\n rgbe[3] = (stbi_uc) stbi__get8(s);\n stbi__hdr_convert(hdr_data, rgbe, req_comp);\n i = 1;\n j = 0;\n STBI_FREE(scanline);\n goto main_decode_loop; // yes, this makes no sense\n }\n len <<= 8;\n len |= stbi__get8(s);\n if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf(\"invalid decoded scanline length\", \"corrupt HDR\"); }\n if (scanline == NULL) {\n scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0);\n if (!scanline) {\n STBI_FREE(hdr_data);\n return stbi__errpf(\"outofmem\", \"Out of memory\");\n }\n }\n\n for (k = 0; k < 4; ++k) {\n int nleft;\n i = 0;\n while ((nleft = width - i) > 0) {\n count = stbi__get8(s);\n if (count > 128) {\n // Run\n value = stbi__get8(s);\n count -= 128;\n if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf(\"corrupt\", \"bad RLE data in HDR\"); }\n for (z = 0; z < count; ++z)\n scanline[i++ * 4 + k] = value;\n } else {\n // Dump\n if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf(\"corrupt\", \"bad RLE data in HDR\"); }\n for (z = 0; z < count; ++z)\n scanline[i++ * 4 + k] = stbi__get8(s);\n }\n }\n }\n for (i=0; i < width; ++i)\n stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp);\n }\n if (scanline)\n STBI_FREE(scanline);\n }\n\n return hdr_data;\n}\n\nstatic int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)\n{\n char buffer[STBI__HDR_BUFLEN];\n char *token;\n int valid = 0;\n int dummy;\n\n if (!x) x = &dummy;\n if (!y) y = &dummy;\n if (!comp) comp = &dummy;\n\n if (stbi__hdr_test(s) == 0) {\n stbi__rewind( s );\n return 0;\n }\n\n for(;;) {\n token = stbi__hdr_gettoken(s,buffer);\n if (token[0] == 0) break;\n if (strcmp(token, \"FORMAT=32-bit_rle_rgbe\") == 0) valid = 1;\n }\n\n if (!valid) {\n stbi__rewind( s );\n return 0;\n }\n token = stbi__hdr_gettoken(s,buffer);\n if (strncmp(token, \"-Y \", 3)) {\n stbi__rewind( s );\n return 0;\n }\n token += 3;\n *y = (int) strtol(token, &token, 10);\n while (*token == ' ') ++token;\n if (strncmp(token, \"+X \", 3)) {\n stbi__rewind( s );\n return 0;\n }\n token += 3;\n *x = (int) strtol(token, NULL, 10);\n *comp = 3;\n return 1;\n}\n#endif // STBI_NO_HDR\n\n#ifndef STBI_NO_BMP\nstatic int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)\n{\n void *p;\n stbi__bmp_data info;\n\n info.all_a = 255;\n p = stbi__bmp_parse_header(s, &info);\n if (p == NULL) {\n stbi__rewind( s );\n return 0;\n }\n if (x) *x = s->img_x;\n if (y) *y = s->img_y;\n if (comp) {\n if (info.bpp == 24 && info.ma == 0xff000000)\n *comp = 3;\n else\n *comp = info.ma ? 4 : 3;\n }\n return 1;\n}\n#endif\n\n#ifndef STBI_NO_PSD\nstatic int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)\n{\n int channelCount, dummy, depth;\n if (!x) x = &dummy;\n if (!y) y = &dummy;\n if (!comp) comp = &dummy;\n if (stbi__get32be(s) != 0x38425053) {\n stbi__rewind( s );\n return 0;\n }\n if (stbi__get16be(s) != 1) {\n stbi__rewind( s );\n return 0;\n }\n stbi__skip(s, 6);\n channelCount = stbi__get16be(s);\n if (channelCount < 0 || channelCount > 16) {\n stbi__rewind( s );\n return 0;\n }\n *y = stbi__get32be(s);\n *x = stbi__get32be(s);\n depth = stbi__get16be(s);\n if (depth != 8 && depth != 16) {\n stbi__rewind( s );\n return 0;\n }\n if (stbi__get16be(s) != 3) {\n stbi__rewind( s );\n return 0;\n }\n *comp = 4;\n return 1;\n}\n\nstatic int stbi__psd_is16(stbi__context *s)\n{\n int channelCount, depth;\n if (stbi__get32be(s) != 0x38425053) {\n stbi__rewind( s );\n return 0;\n }\n if (stbi__get16be(s) != 1) {\n stbi__rewind( s );\n return 0;\n }\n stbi__skip(s, 6);\n channelCount = stbi__get16be(s);\n if (channelCount < 0 || channelCount > 16) {\n stbi__rewind( s );\n return 0;\n }\n STBI_NOTUSED(stbi__get32be(s));\n STBI_NOTUSED(stbi__get32be(s));\n depth = stbi__get16be(s);\n if (depth != 16) {\n stbi__rewind( s );\n return 0;\n }\n return 1;\n}\n#endif\n\n#ifndef STBI_NO_PIC\nstatic int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)\n{\n int act_comp=0,num_packets=0,chained,dummy;\n stbi__pic_packet packets[10];\n\n if (!x) x = &dummy;\n if (!y) y = &dummy;\n if (!comp) comp = &dummy;\n\n if (!stbi__pic_is4(s,\"\\x53\\x80\\xF6\\x34\")) {\n stbi__rewind(s);\n return 0;\n }\n\n stbi__skip(s, 88);\n\n *x = stbi__get16be(s);\n *y = stbi__get16be(s);\n if (stbi__at_eof(s)) {\n stbi__rewind( s);\n return 0;\n }\n if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) {\n stbi__rewind( s );\n return 0;\n }\n\n stbi__skip(s, 8);\n\n do {\n stbi__pic_packet *packet;\n\n if (num_packets==sizeof(packets)/sizeof(packets[0]))\n return 0;\n\n packet = &packets[num_packets++];\n chained = stbi__get8(s);\n packet->size = stbi__get8(s);\n packet->type = stbi__get8(s);\n packet->channel = stbi__get8(s);\n act_comp |= packet->channel;\n\n if (stbi__at_eof(s)) {\n stbi__rewind( s );\n return 0;\n }\n if (packet->size != 8) {\n stbi__rewind( s );\n return 0;\n }\n } while (chained);\n\n *comp = (act_comp & 0x10 ? 4 : 3);\n\n return 1;\n}\n#endif\n\n// *************************************************************************************************\n// Portable Gray Map and Portable Pixel Map loader\n// by Ken Miller\n//\n// PGM: http://netpbm.sourceforge.net/doc/pgm.html\n// PPM: http://netpbm.sourceforge.net/doc/ppm.html\n//\n// Known limitations:\n// Does not support comments in the header section\n// Does not support ASCII image data (formats P2 and P3)\n\n#ifndef STBI_NO_PNM\n\nstatic int stbi__pnm_test(stbi__context *s)\n{\n char p, t;\n p = (char) stbi__get8(s);\n t = (char) stbi__get8(s);\n if (p != 'P' || (t != '5' && t != '6')) {\n stbi__rewind( s );\n return 0;\n }\n return 1;\n}\n\nstatic void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)\n{\n stbi_uc *out;\n STBI_NOTUSED(ri);\n\n ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n);\n if (ri->bits_per_channel == 0)\n return 0;\n\n if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc(\"too large\",\"Very large image (corrupt?)\");\n if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc(\"too large\",\"Very large image (corrupt?)\");\n\n *x = s->img_x;\n *y = s->img_y;\n if (comp) *comp = s->img_n;\n\n if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0))\n return stbi__errpuc(\"too large\", \"PNM too large\");\n\n out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0);\n if (!out) return stbi__errpuc(\"outofmem\", \"Out of memory\");\n if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) {\n STBI_FREE(out);\n return stbi__errpuc(\"bad PNM\", \"PNM file truncated\");\n }\n\n if (req_comp && req_comp != s->img_n) {\n if (ri->bits_per_channel == 16) {\n out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y);\n } else {\n out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);\n }\n if (out == NULL) return out; // stbi__convert_format frees input on failure\n }\n return out;\n}\n\nstatic int stbi__pnm_isspace(char c)\n{\n return c == ' ' || c == '\\t' || c == '\\n' || c == '\\v' || c == '\\f' || c == '\\r';\n}\n\nstatic void stbi__pnm_skip_whitespace(stbi__context *s, char *c)\n{\n for (;;) {\n while (!stbi__at_eof(s) && stbi__pnm_isspace(*c))\n *c = (char) stbi__get8(s);\n\n if (stbi__at_eof(s) || *c != '#')\n break;\n\n while (!stbi__at_eof(s) && *c != '\\n' && *c != '\\r' )\n *c = (char) stbi__get8(s);\n }\n}\n\nstatic int stbi__pnm_isdigit(char c)\n{\n return c >= '0' && c <= '9';\n}\n\nstatic int stbi__pnm_getinteger(stbi__context *s, char *c)\n{\n int value = 0;\n\n while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {\n value = value*10 + (*c - '0');\n *c = (char) stbi__get8(s);\n if((value > 214748364) || (value == 214748364 && *c > '7'))\n return stbi__err(\"integer parse overflow\", \"Parsing an integer in the PPM header overflowed a 32-bit int\");\n }\n\n return value;\n}\n\nstatic int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)\n{\n int maxv, dummy;\n char c, p, t;\n\n if (!x) x = &dummy;\n if (!y) y = &dummy;\n if (!comp) comp = &dummy;\n\n stbi__rewind(s);\n\n // Get identifier\n p = (char) stbi__get8(s);\n t = (char) stbi__get8(s);\n if (p != 'P' || (t != '5' && t != '6')) {\n stbi__rewind(s);\n return 0;\n }\n\n *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm\n\n c = (char) stbi__get8(s);\n stbi__pnm_skip_whitespace(s, &c);\n\n *x = stbi__pnm_getinteger(s, &c); // read width\n if(*x == 0)\n return stbi__err(\"invalid width\", \"PPM image header had zero or overflowing width\");\n stbi__pnm_skip_whitespace(s, &c);\n\n *y = stbi__pnm_getinteger(s, &c); // read height\n if (*y == 0)\n return stbi__err(\"invalid width\", \"PPM image header had zero or overflowing width\");\n stbi__pnm_skip_whitespace(s, &c);\n\n maxv = stbi__pnm_getinteger(s, &c); // read max value\n if (maxv > 65535)\n return stbi__err(\"max value > 65535\", \"PPM image supports only 8-bit and 16-bit images\");\n else if (maxv > 255)\n return 16;\n else\n return 8;\n}\n\nstatic int stbi__pnm_is16(stbi__context *s)\n{\n if (stbi__pnm_info(s, NULL, NULL, NULL) == 16)\n\t return 1;\n return 0;\n}\n#endif\n\nstatic int stbi__info_main(stbi__context *s, int *x, int *y, int *comp)\n{\n #ifndef STBI_NO_JPEG\n if (stbi__jpeg_info(s, x, y, comp)) return 1;\n #endif\n\n #ifndef STBI_NO_PNG\n if (stbi__png_info(s, x, y, comp)) return 1;\n #endif\n\n #ifndef STBI_NO_GIF\n if (stbi__gif_info(s, x, y, comp)) return 1;\n #endif\n\n #ifndef STBI_NO_BMP\n if (stbi__bmp_info(s, x, y, comp)) return 1;\n #endif\n\n #ifndef STBI_NO_PSD\n if (stbi__psd_info(s, x, y, comp)) return 1;\n #endif\n\n #ifndef STBI_NO_PIC\n if (stbi__pic_info(s, x, y, comp)) return 1;\n #endif\n\n #ifndef STBI_NO_PNM\n if (stbi__pnm_info(s, x, y, comp)) return 1;\n #endif\n\n #ifndef STBI_NO_HDR\n if (stbi__hdr_info(s, x, y, comp)) return 1;\n #endif\n\n // test tga last because it's a crappy test!\n #ifndef STBI_NO_TGA\n if (stbi__tga_info(s, x, y, comp))\n return 1;\n #endif\n return stbi__err(\"unknown image type\", \"Image not of any known type, or corrupt\");\n}\n\nstatic int stbi__is_16_main(stbi__context *s)\n{\n #ifndef STBI_NO_PNG\n if (stbi__png_is16(s)) return 1;\n #endif\n\n #ifndef STBI_NO_PSD\n if (stbi__psd_is16(s)) return 1;\n #endif\n\n #ifndef STBI_NO_PNM\n if (stbi__pnm_is16(s)) return 1;\n #endif\n return 0;\n}\n\n#ifndef STBI_NO_STDIO\nSTBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)\n{\n FILE *f = stbi__fopen(filename, \"rb\");\n int result;\n if (!f) return stbi__err(\"can't fopen\", \"Unable to open file\");\n result = stbi_info_from_file(f, x, y, comp);\n fclose(f);\n return result;\n}\n\nSTBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp)\n{\n int r;\n stbi__context s;\n long pos = ftell(f);\n stbi__start_file(&s, f);\n r = stbi__info_main(&s,x,y,comp);\n fseek(f,pos,SEEK_SET);\n return r;\n}\n\nSTBIDEF int stbi_is_16_bit(char const *filename)\n{\n FILE *f = stbi__fopen(filename, \"rb\");\n int result;\n if (!f) return stbi__err(\"can't fopen\", \"Unable to open file\");\n result = stbi_is_16_bit_from_file(f);\n fclose(f);\n return result;\n}\n\nSTBIDEF int stbi_is_16_bit_from_file(FILE *f)\n{\n int r;\n stbi__context s;\n long pos = ftell(f);\n stbi__start_file(&s, f);\n r = stbi__is_16_main(&s);\n fseek(f,pos,SEEK_SET);\n return r;\n}\n#endif // !STBI_NO_STDIO\n\nSTBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)\n{\n stbi__context s;\n stbi__start_mem(&s,buffer,len);\n return stbi__info_main(&s,x,y,comp);\n}\n\nSTBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)\n{\n stbi__context s;\n stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);\n return stbi__info_main(&s,x,y,comp);\n}\n\nSTBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)\n{\n stbi__context s;\n stbi__start_mem(&s,buffer,len);\n return stbi__is_16_main(&s);\n}\n\nSTBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user)\n{\n stbi__context s;\n stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);\n return stbi__is_16_main(&s);\n}\n\n#endif // STB_IMAGE_IMPLEMENTATION\n\n/*\n revision history:\n 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs\n 2.19 (2018-02-11) fix warning\n 2.18 (2018-01-30) fix warnings\n 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug\n 1-bit BMP\n *_is_16_bit api\n avoid warnings\n 2.16 (2017-07-23) all functions have 16-bit variants;\n STBI_NO_STDIO works again;\n compilation fixes;\n fix rounding in unpremultiply;\n optimize vertical flip;\n disable raw_len validation;\n documentation fixes\n 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode;\n warning fixes; disable run-time SSE detection on gcc;\n uniform handling of optional \"return\" values;\n thread-safe initialization of zlib tables\n 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs\n 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now\n 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes\n 2.11 (2016-04-02) allocate large structures on the stack\n remove white matting for transparent PSD\n fix reported channel count for PNG & BMP\n re-enable SSE2 in non-gcc 64-bit\n support RGB-formatted JPEG\n read 16-bit PNGs (only as 8-bit)\n 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED\n 2.09 (2016-01-16) allow comments in PNM files\n 16-bit-per-pixel TGA (not bit-per-component)\n info() for TGA could break due to .hdr handling\n info() for BMP to shares code instead of sloppy parse\n can use STBI_REALLOC_SIZED if allocator doesn't support realloc\n code cleanup\n 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA\n 2.07 (2015-09-13) fix compiler warnings\n partial animated GIF support\n limited 16-bpc PSD support\n #ifdef unused functions\n bug with < 92 byte PIC,PNM,HDR,TGA\n 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value\n 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning\n 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit\n 2.03 (2015-04-12) extra corruption checking (mmozeiko)\n stbi_set_flip_vertically_on_load (nguillemot)\n fix NEON support; fix mingw support\n 2.02 (2015-01-19) fix incorrect assert, fix warning\n 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2\n 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG\n 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg)\n progressive JPEG (stb)\n PGM/PPM support (Ken Miller)\n STBI_MALLOC,STBI_REALLOC,STBI_FREE\n GIF bugfix -- seemingly never worked\n STBI_NO_*, STBI_ONLY_*\n 1.48 (2014-12-14) fix incorrectly-named assert()\n 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb)\n optimize PNG (ryg)\n fix bug in interlaced PNG with user-specified channel count (stb)\n 1.46 (2014-08-26)\n fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG\n 1.45 (2014-08-16)\n fix MSVC-ARM internal compiler error by wrapping malloc\n 1.44 (2014-08-07)\n various warning fixes from Ronny Chevalier\n 1.43 (2014-07-15)\n fix MSVC-only compiler problem in code changed in 1.42\n 1.42 (2014-07-09)\n don't define _CRT_SECURE_NO_WARNINGS (affects user code)\n fixes to stbi__cleanup_jpeg path\n added STBI_ASSERT to avoid requiring assert.h\n 1.41 (2014-06-25)\n fix search&replace from 1.36 that messed up comments/error messages\n 1.40 (2014-06-22)\n fix gcc struct-initialization warning\n 1.39 (2014-06-15)\n fix to TGA optimization when req_comp != number of components in TGA;\n fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite)\n add support for BMP version 5 (more ignored fields)\n 1.38 (2014-06-06)\n suppress MSVC warnings on integer casts truncating values\n fix accidental rename of 'skip' field of I/O\n 1.37 (2014-06-04)\n remove duplicate typedef\n 1.36 (2014-06-03)\n convert to header file single-file library\n if de-iphone isn't set, load iphone images color-swapped instead of returning NULL\n 1.35 (2014-05-27)\n various warnings\n fix broken STBI_SIMD path\n fix bug where stbi_load_from_file no longer left file pointer in correct place\n fix broken non-easy path for 32-bit BMP (possibly never used)\n TGA optimization by Arseny Kapoulkine\n 1.34 (unknown)\n use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case\n 1.33 (2011-07-14)\n make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements\n 1.32 (2011-07-13)\n support for \"info\" function for all supported filetypes (SpartanJ)\n 1.31 (2011-06-20)\n a few more leak fixes, bug in PNG handling (SpartanJ)\n 1.30 (2011-06-11)\n added ability to load files via callbacks to accomidate custom input streams (Ben Wenger)\n removed deprecated format-specific test/load functions\n removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway\n error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha)\n fix inefficiency in decoding 32-bit BMP (David Woo)\n 1.29 (2010-08-16)\n various warning fixes from Aurelien Pocheville\n 1.28 (2010-08-01)\n fix bug in GIF palette transparency (SpartanJ)\n 1.27 (2010-08-01)\n cast-to-stbi_uc to fix warnings\n 1.26 (2010-07-24)\n fix bug in file buffering for PNG reported by SpartanJ\n 1.25 (2010-07-17)\n refix trans_data warning (Won Chun)\n 1.24 (2010-07-12)\n perf improvements reading from files on platforms with lock-heavy fgetc()\n minor perf improvements for jpeg\n deprecated type-specific functions so we'll get feedback if they're needed\n attempt to fix trans_data warning (Won Chun)\n 1.23 fixed bug in iPhone support\n 1.22 (2010-07-10)\n removed image *writing* support\n stbi_info support from Jetro Lauha\n GIF support from Jean-Marc Lienher\n iPhone PNG-extensions from James Brown\n warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva)\n 1.21 fix use of 'stbi_uc' in header (reported by jon blow)\n 1.20 added support for Softimage PIC, by Tom Seddon\n 1.19 bug in interlaced PNG corruption check (found by ryg)\n 1.18 (2008-08-02)\n fix a threading bug (local mutable static)\n 1.17 support interlaced PNG\n 1.16 major bugfix - stbi__convert_format converted one too many pixels\n 1.15 initialize some fields for thread safety\n 1.14 fix threadsafe conversion bug\n header-file-only version (#define STBI_HEADER_FILE_ONLY before including)\n 1.13 threadsafe\n 1.12 const qualifiers in the API\n 1.11 Support installable IDCT, colorspace conversion routines\n 1.10 Fixes for 64-bit (don't use \"unsigned long\")\n optimized upsampling by Fabian \"ryg\" Giesen\n 1.09 Fix format-conversion for PSD code (bad global variables!)\n 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz\n 1.07 attempt to fix C++ warning/errors again\n 1.06 attempt to fix C++ warning/errors again\n 1.05 fix TGA loading to return correct *comp and use good luminance calc\n 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free\n 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR\n 1.02 support for (subset of) HDR files, float interface for preferred access to them\n 1.01 fix bug: possible bug in handling right-side up bmps... not sure\n fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all\n 1.00 interface to zlib that skips zlib header\n 0.99 correct handling of alpha in palette\n 0.98 TGA loader by lonesock; dynamically add loaders (untested)\n 0.97 jpeg errors on too large a file; also catch another malloc failure\n 0.96 fix detection of invalid v value - particleman@mollyrocket forum\n 0.95 during header scan, seek to markers in case of padding\n 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same\n 0.93 handle jpegtran output; verbose errors\n 0.92 read 4,8,16,24,32-bit BMP files of several formats\n 0.91 output 24-bit Windows 3.0 BMP files\n 0.90 fix a few more warnings; bump version number to approach 1.0\n 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd\n 0.60 fix compiling as c++\n 0.59 fix warnings: merge Dave Moore's -Wall fixes\n 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian\n 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available\n 0.56 fix bug: zlib uncompressed mode len vs. nlen\n 0.55 fix bug: restart_interval not initialized to 0\n 0.54 allow NULL for 'int *comp'\n 0.53 fix bug in png 3->4; speedup png decoding\n 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments\n 0.51 obey req_comp requests, 1-component jpegs return as 1-component,\n on 'test' only check type, not whether we support this variant\n 0.50 (2006-11-19)\n first released version\n*/\n\n\n/*\n------------------------------------------------------------------------------\nThis software is available under 2 licenses -- choose whichever you prefer.\n------------------------------------------------------------------------------\nALTERNATIVE A - MIT License\nCopyright (c) 2017 Sean Barrett\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis software and associated documentation files (the \"Software\"), to deal in\nthe Software without restriction, including without limitation the rights to\nuse, copy, modify, merge, publish, distribute, sublicense, and/or sell copies\nof the Software, and to permit persons to whom the Software is furnished to do\nso, subject to the following conditions:\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n------------------------------------------------------------------------------\nALTERNATIVE B - Public Domain (www.unlicense.org)\nThis is free and unencumbered software released into the public domain.\nAnyone is free to copy, modify, publish, use, compile, sell, or distribute this\nsoftware, either in source code form or as a compiled binary, for any purpose,\ncommercial or non-commercial, and by any means.\nIn jurisdictions that recognize copyright laws, the author or authors of this\nsoftware dedicate any and all copyright interest in the software to the public\ndomain. We make this dedication for the benefit of the public at large and to\nthe detriment of our heirs and successors. We intend this dedication to be an\novert act of relinquishment in perpetuity of all present and future rights to\nthis software under copyright law.\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\nACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\nWITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n------------------------------------------------------------------------------\n*/\n"}}},{"rowIdx":22982,"cells":{"text":{"kind":"string","value":"/* ioapi.c -- IO base function header for compress/uncompress .zip\n part of the MiniZip project\n\n Copyright (C) 2012-2017 Nathan Moinvaziri\n https://github.com/nmoinvaz/minizip\n Modifications for Zip64 support\n Copyright (C) 2009-2010 Mathias Svensson\n http://result42.com\n Copyright (C) 1998-2010 Gilles Vollant\n http://www.winimage.com/zLibDll/minizip.html\n\n This program is distributed under the terms of the same license as zlib.\n See the accompanying LICENSE file for the full text of the license.\n*/\n\n#include <stdlib.h>\n#include <string.h>\n\n#if defined unix || defined __APPLE__\n#include <sys/types.h>\n#include <unistd.h>\n#endif\n\n#include \"ioapi.h\"\n\n#if defined(_WIN32)\n# define snprintf _snprintf\n#endif\n\nvoidpf call_zopen64(const zlib_filefunc64_32_def *pfilefunc, const void *filename, int mode)\n{\n if (pfilefunc->zfile_func64.zopen64_file != NULL)\n return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque, filename, mode);\n return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque, (const char*)filename, mode);\n}\n\nvoidpf call_zopendisk64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint32_t number_disk, int mode)\n{\n if (pfilefunc->zfile_func64.zopendisk64_file != NULL)\n return (*(pfilefunc->zfile_func64.zopendisk64_file)) (pfilefunc->zfile_func64.opaque, filestream, number_disk, mode);\n return (*(pfilefunc->zopendisk32_file))(pfilefunc->zfile_func64.opaque, filestream, number_disk, mode);\n}\n\nlong call_zseek64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint64_t offset, int origin)\n{\n uint32_t offset_truncated = 0;\n if (pfilefunc->zfile_func64.zseek64_file != NULL)\n return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);\n offset_truncated = (uint32_t)offset;\n if (offset_truncated != offset)\n return -1;\n return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream, offset_truncated, origin);\n}\n\nuint64_t call_ztell64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream)\n{\n uint64_t position;\n if (pfilefunc->zfile_func64.zseek64_file != NULL)\n return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque, filestream);\n position = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque, filestream);\n if ((position) == UINT32_MAX)\n return (uint64_t)-1;\n return position;\n}\n\nvoid fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def *p_filefunc64_32, const zlib_filefunc_def *p_filefunc32)\n{\n p_filefunc64_32->zfile_func64.zopen64_file = NULL;\n p_filefunc64_32->zfile_func64.zopendisk64_file = NULL;\n p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;\n p_filefunc64_32->zopendisk32_file = p_filefunc32->zopendisk_file;\n p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;\n p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;\n p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;\n p_filefunc64_32->zfile_func64.ztell64_file = NULL;\n p_filefunc64_32->zfile_func64.zseek64_file = NULL;\n p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;\n p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;\n p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;\n p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;\n p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;\n}\n\nstatic voidpf ZCALLBACK fopen_file_func(ZIP_UNUSED voidpf opaque, const char *filename, int mode);\nstatic uint32_t ZCALLBACK fread_file_func(voidpf opaque, voidpf stream, void* buf, uint32_t size);\nstatic uint32_t ZCALLBACK fwrite_file_func(voidpf opaque, voidpf stream, const void *buf, uint32_t size);\nstatic uint64_t ZCALLBACK ftell64_file_func(voidpf opaque, voidpf stream);\nstatic long ZCALLBACK fseek64_file_func(voidpf opaque, voidpf stream, uint64_t offset, int origin);\nstatic int ZCALLBACK fclose_file_func(voidpf opaque, voidpf stream);\nstatic int ZCALLBACK ferror_file_func(voidpf opaque, voidpf stream);\n\ntypedef struct \n{\n FILE *file;\n int filenameLength;\n void *filename;\n} FILE_IOPOSIX;\n\nstatic voidpf file_build_ioposix(FILE *file, const char *filename)\n{\n FILE_IOPOSIX *ioposix = NULL;\n if (file == NULL)\n return NULL;\n ioposix = (FILE_IOPOSIX*)malloc(sizeof(FILE_IOPOSIX));\n ioposix->file = file;\n ioposix->filenameLength = (int)strlen(filename) + 1;\n ioposix->filename = (char*)malloc(ioposix->filenameLength * sizeof(char));\n strncpy((char*)ioposix->filename, filename, ioposix->filenameLength);\n return (voidpf)ioposix;\n}\n\nstatic voidpf ZCALLBACK fopen_file_func(ZIP_UNUSED voidpf opaque, const char *filename, int mode)\n{\n FILE* file = NULL;\n const char *mode_fopen = NULL;\n if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ)\n mode_fopen = \"rb\";\n else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)\n mode_fopen = \"r+b\";\n else if (mode & ZLIB_FILEFUNC_MODE_CREATE)\n mode_fopen = \"wb\";\n\n if ((filename != NULL) && (mode_fopen != NULL))\n {\n file = fopen(filename, mode_fopen);\n return file_build_ioposix(file, filename);\n }\n return file;\n}\n\nstatic voidpf ZCALLBACK fopen64_file_func(ZIP_UNUSED voidpf opaque, const void *filename, int mode)\n{\n FILE* file = NULL;\n const char *mode_fopen = NULL;\n if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ)\n mode_fopen = \"rb\";\n else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)\n mode_fopen = \"r+b\";\n else if (mode & ZLIB_FILEFUNC_MODE_CREATE)\n mode_fopen = \"wb\";\n\n if ((filename != NULL) && (mode_fopen != NULL))\n {\n file = fopen64((const char*)filename, mode_fopen);\n return file_build_ioposix(file, (const char*)filename);\n }\n return file;\n}\n\nstatic voidpf ZCALLBACK fopendisk64_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)\n{\n FILE_IOPOSIX *ioposix = NULL;\n char *diskFilename = NULL;\n voidpf ret = NULL;\n int i = 0;\n\n if (stream == NULL)\n return NULL;\n ioposix = (FILE_IOPOSIX*)stream;\n diskFilename = (char*)malloc(ioposix->filenameLength * sizeof(char));\n strncpy(diskFilename, (const char*)ioposix->filename, ioposix->filenameLength);\n for (i = ioposix->filenameLength - 1; i >= 0; i -= 1)\n {\n if (diskFilename[i] != '.')\n continue;\n snprintf(&diskFilename[i], ioposix->filenameLength - i, \".z%02u\", number_disk + 1);\n break;\n }\n if (i >= 0)\n ret = fopen64_file_func(opaque, diskFilename, mode);\n free(diskFilename);\n return ret;\n}\n\nstatic voidpf ZCALLBACK fopendisk_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)\n{\n FILE_IOPOSIX *ioposix = NULL;\n char *diskFilename = NULL;\n voidpf ret = NULL;\n int i = 0;\n\n if (stream == NULL)\n return NULL;\n ioposix = (FILE_IOPOSIX*)stream;\n diskFilename = (char*)malloc(ioposix->filenameLength * sizeof(char));\n strncpy(diskFilename, (const char*)ioposix->filename, ioposix->filenameLength);\n for (i = ioposix->filenameLength - 1; i >= 0; i -= 1)\n {\n if (diskFilename[i] != '.')\n continue;\n snprintf(&diskFilename[i], ioposix->filenameLength - i, \".z%02u\", number_disk + 1);\n break;\n }\n if (i >= 0)\n ret = fopen_file_func(opaque, diskFilename, mode);\n free(diskFilename);\n return ret;\n}\n\nstatic uint32_t ZCALLBACK fread_file_func(ZIP_UNUSED voidpf opaque, voidpf stream, void* buf, uint32_t size)\n{\n FILE_IOPOSIX *ioposix = NULL;\n uint32_t read = (uint32_t)-1;\n if (stream == NULL)\n return read;\n ioposix = (FILE_IOPOSIX*)stream;\n read = (uint32_t)fread(buf, 1, (size_t)size, ioposix->file);\n return read;\n}\n\nstatic uint32_t ZCALLBACK fwrite_file_func(ZIP_UNUSED voidpf opaque, voidpf stream, const void *buf, uint32_t size)\n{\n FILE_IOPOSIX *ioposix = NULL;\n uint32_t written = (uint32_t)-1;\n if (stream == NULL)\n return written;\n ioposix = (FILE_IOPOSIX*)stream;\n written = (uint32_t)fwrite(buf, 1, (size_t)size, ioposix->file);\n return written;\n}\n\nstatic long ZCALLBACK ftell_file_func(ZIP_UNUSED voidpf opaque, voidpf stream)\n{\n FILE_IOPOSIX *ioposix = NULL;\n long ret = -1;\n if (stream == NULL)\n return ret;\n ioposix = (FILE_IOPOSIX*)stream;\n ret = ftell(ioposix->file);\n return ret;\n}\n\nstatic uint64_t ZCALLBACK ftell64_file_func(ZIP_UNUSED voidpf opaque, voidpf stream)\n{\n FILE_IOPOSIX *ioposix = NULL;\n uint64_t ret = (uint64_t)-1;\n if (stream == NULL)\n return ret;\n ioposix = (FILE_IOPOSIX*)stream;\n ret = ftello64(ioposix->file);\n return ret;\n}\n\nstatic long ZCALLBACK fseek_file_func(ZIP_UNUSED voidpf opaque, voidpf stream, uint32_t offset, int origin)\n{\n FILE_IOPOSIX *ioposix = NULL;\n int fseek_origin = 0;\n long ret = 0;\n\n if (stream == NULL)\n return -1;\n ioposix = (FILE_IOPOSIX*)stream;\n\n switch (origin)\n {\n case ZLIB_FILEFUNC_SEEK_CUR:\n fseek_origin = SEEK_CUR;\n break;\n case ZLIB_FILEFUNC_SEEK_END:\n fseek_origin = SEEK_END;\n break;\n case ZLIB_FILEFUNC_SEEK_SET:\n fseek_origin = SEEK_SET;\n break;\n default:\n return -1;\n }\n if (fseek(ioposix->file, offset, fseek_origin) != 0)\n ret = -1;\n return ret;\n}\n\nstatic long ZCALLBACK fseek64_file_func(ZIP_UNUSED voidpf opaque, voidpf stream, uint64_t offset, int origin)\n{\n FILE_IOPOSIX *ioposix = NULL;\n int fseek_origin = 0;\n long ret = 0;\n\n if (stream == NULL)\n return -1;\n ioposix = (FILE_IOPOSIX*)stream;\n\n switch (origin)\n {\n case ZLIB_FILEFUNC_SEEK_CUR:\n fseek_origin = SEEK_CUR;\n break;\n case ZLIB_FILEFUNC_SEEK_END:\n fseek_origin = SEEK_END;\n break;\n case ZLIB_FILEFUNC_SEEK_SET:\n fseek_origin = SEEK_SET;\n break;\n default:\n return -1;\n }\n\n if (fseeko64(ioposix->file, offset, fseek_origin) != 0)\n ret = -1;\n\n return ret;\n}\n\nstatic int ZCALLBACK fclose_file_func(ZIP_UNUSED voidpf opaque, voidpf stream)\n{\n FILE_IOPOSIX *ioposix = NULL;\n int ret = -1;\n if (stream == NULL)\n return ret;\n ioposix = (FILE_IOPOSIX*)stream;\n if (ioposix->filename != NULL)\n free(ioposix->filename);\n ret = fclose(ioposix->file);\n free(ioposix);\n return ret;\n}\n\nstatic int ZCALLBACK ferror_file_func(ZIP_UNUSED voidpf opaque, voidpf stream)\n{\n FILE_IOPOSIX *ioposix = NULL;\n int ret = -1;\n if (stream == NULL)\n return ret;\n ioposix = (FILE_IOPOSIX*)stream;\n ret = ferror(ioposix->file);\n return ret;\n}\n\nvoid fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def)\n{\n pzlib_filefunc_def->zopen_file = fopen_file_func;\n pzlib_filefunc_def->zopendisk_file = fopendisk_file_func;\n pzlib_filefunc_def->zread_file = fread_file_func;\n pzlib_filefunc_def->zwrite_file = fwrite_file_func;\n pzlib_filefunc_def->ztell_file = ftell_file_func;\n pzlib_filefunc_def->zseek_file = fseek_file_func;\n pzlib_filefunc_def->zclose_file = fclose_file_func;\n pzlib_filefunc_def->zerror_file = ferror_file_func;\n pzlib_filefunc_def->opaque = NULL;\n}\n\nvoid fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def)\n{\n pzlib_filefunc_def->zopen64_file = fopen64_file_func;\n pzlib_filefunc_def->zopendisk64_file = fopendisk64_file_func;\n pzlib_filefunc_def->zread_file = fread_file_func;\n pzlib_filefunc_def->zwrite_file = fwrite_file_func;\n pzlib_filefunc_def->ztell64_file = ftell64_file_func;\n pzlib_filefunc_def->zseek64_file = fseek64_file_func;\n pzlib_filefunc_def->zclose_file = fclose_file_func;\n pzlib_filefunc_def->zerror_file = ferror_file_func;\n pzlib_filefunc_def->opaque = NULL;\n}\n"}}},{"rowIdx":22983,"cells":{"text":{"kind":"string","value":"/* ioapi.h -- IO base function header for compress/uncompress .zip\n part of the MiniZip project\n\n Copyright (C) 2012-2017 Nathan Moinvaziri\n https://github.com/nmoinvaz/minizip\n Copyright (C) 2009-2010 Mathias Svensson\n Modifications for Zip64 support\n http://result42.com\n Copyright (C) 1998-2010 Gilles Vollant\n http://www.winimage.com/zLibDll/minizip.html\n\n This program is distributed under the terms of the same license as zlib.\n See the accompanying LICENSE file for the full text of the license.\n*/\n\n#ifndef _ZLIBIOAPI64_H\n#define _ZLIBIOAPI64_H\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <stdint.h>\n\n#include \"zlib.h\"\n\n#ifdef __GNUC__\n# define ZIP_UNUSED __attribute__((__unused__))\n#else\n# define ZIP_UNUSED\n#endif\n\n#if defined(USE_FILE32API)\n# define fopen64 fopen\n# define ftello64 ftell\n# define fseeko64 fseek\n#else\n# if defined(_MSC_VER)\n# define fopen64 fopen\n# if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))\n# define ftello64 _ftelli64\n# define fseeko64 _fseeki64\n# else /* old MSC */\n# define ftello64 ftell\n# define fseeko64 fseek\n# endif\n# else\n# define fopen64 fopen\n# define ftello64 ftello\n# define fseeko64 fseeko\n# endif\n#endif\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#define ZLIB_FILEFUNC_SEEK_CUR (1)\n#define ZLIB_FILEFUNC_SEEK_END (2)\n#define ZLIB_FILEFUNC_SEEK_SET (0)\n\n#define ZLIB_FILEFUNC_MODE_READ (1)\n#define ZLIB_FILEFUNC_MODE_WRITE (2)\n#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)\n#define ZLIB_FILEFUNC_MODE_EXISTING (4)\n#define ZLIB_FILEFUNC_MODE_CREATE (8)\n\n#ifndef ZCALLBACK\n# if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || \\\n defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)\n# define ZCALLBACK CALLBACK\n# else\n# define ZCALLBACK\n# endif\n#endif\n\ntypedef voidpf (ZCALLBACK *open_file_func) (voidpf opaque, const char *filename, int mode);\ntypedef voidpf (ZCALLBACK *opendisk_file_func) (voidpf opaque, voidpf stream, uint32_t number_disk, int mode);\ntypedef uint32_t (ZCALLBACK *read_file_func) (voidpf opaque, voidpf stream, void* buf, uint32_t size);\ntypedef uint32_t (ZCALLBACK *write_file_func) (voidpf opaque, voidpf stream, const void *buf, uint32_t size);\ntypedef int (ZCALLBACK *close_file_func) (voidpf opaque, voidpf stream);\ntypedef int (ZCALLBACK *error_file_func) (voidpf opaque, voidpf stream);\n\ntypedef long (ZCALLBACK *tell_file_func) (voidpf opaque, voidpf stream);\ntypedef long (ZCALLBACK *seek_file_func) (voidpf opaque, voidpf stream, uint32_t offset, int origin);\n\n/* here is the \"old\" 32 bits structure structure */\ntypedef struct zlib_filefunc_def_s\n{\n open_file_func zopen_file;\n opendisk_file_func zopendisk_file;\n read_file_func zread_file;\n write_file_func zwrite_file;\n tell_file_func ztell_file;\n seek_file_func zseek_file;\n close_file_func zclose_file;\n error_file_func zerror_file;\n voidpf opaque;\n} zlib_filefunc_def;\n\ntypedef uint64_t (ZCALLBACK *tell64_file_func) (voidpf opaque, voidpf stream);\ntypedef long (ZCALLBACK *seek64_file_func) (voidpf opaque, voidpf stream, uint64_t offset, int origin);\ntypedef voidpf (ZCALLBACK *open64_file_func) (voidpf opaque, const void *filename, int mode);\ntypedef voidpf (ZCALLBACK *opendisk64_file_func)(voidpf opaque, voidpf stream, uint32_t number_disk, int mode);\n\ntypedef struct zlib_filefunc64_def_s\n{\n open64_file_func zopen64_file;\n opendisk64_file_func zopendisk64_file;\n read_file_func zread_file;\n write_file_func zwrite_file;\n tell64_file_func ztell64_file;\n seek64_file_func zseek64_file;\n close_file_func zclose_file;\n error_file_func zerror_file;\n voidpf opaque;\n} zlib_filefunc64_def;\n\nvoid fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def);\nvoid fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def);\n\n/* now internal definition, only for zip.c and unzip.h */\ntypedef struct zlib_filefunc64_32_def_s\n{\n zlib_filefunc64_def zfile_func64;\n open_file_func zopen32_file;\n opendisk_file_func zopendisk32_file;\n tell_file_func ztell32_file;\n seek_file_func zseek32_file;\n} zlib_filefunc64_32_def;\n\n#define ZREAD64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zread_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))\n#define ZWRITE64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zwrite_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))\n/*#define ZTELL64(filefunc,filestream) ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))*/\n/*#define ZSEEK64(filefunc,filestream,pos,mode) ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))*/\n#define ZCLOSE64(filefunc,filestream) ((*((filefunc).zfile_func64.zclose_file)) ((filefunc).zfile_func64.opaque,filestream))\n#define ZERROR64(filefunc,filestream) ((*((filefunc).zfile_func64.zerror_file)) ((filefunc).zfile_func64.opaque,filestream))\n\nvoidpf call_zopen64(const zlib_filefunc64_32_def *pfilefunc,const void*filename, int mode);\nvoidpf call_zopendisk64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint32_t number_disk, int mode);\nlong call_zseek64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint64_t offset, int origin);\nuint64_t call_ztell64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream);\n\nvoid fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def *p_filefunc64_32, const zlib_filefunc_def *p_filefunc32);\n\n#define ZOPEN64(filefunc,filename,mode) (call_zopen64((&(filefunc)),(filename),(mode)))\n#define ZOPENDISK64(filefunc,filestream,diskn,mode) (call_zopendisk64((&(filefunc)),(filestream),(diskn),(mode)))\n#define ZTELL64(filefunc,filestream) (call_ztell64((&(filefunc)),(filestream)))\n#define ZSEEK64(filefunc,filestream,pos,mode) (call_zseek64((&(filefunc)),(filestream),(pos),(mode)))\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif\n"}}},{"rowIdx":22984,"cells":{"text":{"kind":"string","value":"/* ioapi_mem.c -- IO base function header for compress/uncompress .zip\n files using zlib + zip or unzip API\n\n This version of ioapi is designed to access memory rather than files.\n We do use a region of memory to put data in to and take it out of. We do\n not have auto-extending buffers and do not inform anyone else that the\n data has been written. It is really intended for accessing a zip archive\n embedded in an application such that I can write an installer with no\n external files. Creation of archives has not been attempted, although\n parts of the framework are present.\n\n Based on Unzip ioapi.c version 0.22, May 19th, 2003\n\n Copyright (C) 2012-2017 Nathan Moinvaziri\n https://github.com/nmoinvaz/minizip\n Copyright (C) 2003 Justin Fletcher\n Copyright (C) 1998-2003 Gilles Vollant\n http://www.winimage.com/zLibDll/minizip.html\n\n This file is under the same license as the Unzip tool it is distributed\n with.\n*/\n\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n#include \"zlib.h\"\n#include \"ioapi.h\"\n\n#include \"ioapi_mem.h\"\n\n#ifndef IOMEM_BUFFERSIZE\n# define IOMEM_BUFFERSIZE (UINT16_MAX)\n#endif\n\nvoidpf ZCALLBACK fopen_mem_func(voidpf opaque, ZIP_UNUSED const char *filename, int mode)\n{\n ourmemory_t *mem = (ourmemory_t *)opaque;\n if (mem == NULL)\n return NULL; /* Mem structure passed in was null */\n\n if (mode & ZLIB_FILEFUNC_MODE_CREATE)\n {\n if (mem->grow)\n {\n mem->size = IOMEM_BUFFERSIZE;\n mem->base = (char *)malloc(mem->size);\n }\n\n mem->limit = 0; /* When writing we start with 0 bytes written */\n }\n else\n mem->limit = mem->size;\n\n mem->cur_offset = 0;\n\n return mem;\n}\n\nvoidpf ZCALLBACK fopendisk_mem_func(ZIP_UNUSED voidpf opaque, ZIP_UNUSED voidpf stream, ZIP_UNUSED uint32_t number_disk, ZIP_UNUSED int mode)\n{\n /* Not used */\n return NULL;\n}\n\nuint32_t ZCALLBACK fread_mem_func(ZIP_UNUSED voidpf opaque, voidpf stream, void *buf, uint32_t size)\n{\n ourmemory_t *mem = (ourmemory_t *)stream;\n\n if (size > mem->size - mem->cur_offset)\n size = mem->size - mem->cur_offset;\n\n memcpy(buf, mem->base + mem->cur_offset, size);\n mem->cur_offset += size;\n\n return size;\n}\n\nuint32_t ZCALLBACK fwrite_mem_func(ZIP_UNUSED voidpf opaque, voidpf stream, const void *buf, uint32_t size)\n{\n ourmemory_t *mem = (ourmemory_t *)stream;\n uint32_t newmemsize = 0;\n char *newbase = NULL;\n\n if (size > mem->size - mem->cur_offset)\n {\n if (mem->grow)\n {\n newmemsize = mem->size;\n if (size < IOMEM_BUFFERSIZE)\n newmemsize += IOMEM_BUFFERSIZE;\n else\n newmemsize += size;\n newbase = (char *)malloc(newmemsize);\n memcpy(newbase, mem->base, mem->size);\n free(mem->base);\n mem->base = newbase;\n mem->size = newmemsize;\n }\n else\n size = mem->size - mem->cur_offset;\n }\n memcpy(mem->base + mem->cur_offset, buf, size);\n mem->cur_offset += size;\n if (mem->cur_offset > mem->limit)\n mem->limit = mem->cur_offset;\n\n return size;\n}\n\nlong ZCALLBACK ftell_mem_func(ZIP_UNUSED voidpf opaque, voidpf stream)\n{\n ourmemory_t *mem = (ourmemory_t *)stream;\n return mem->cur_offset;\n}\n\nlong ZCALLBACK fseek_mem_func(ZIP_UNUSED voidpf opaque, voidpf stream, uint32_t offset, int origin)\n{\n ourmemory_t *mem = (ourmemory_t *)stream;\n uint32_t new_pos = 0;\n switch (origin)\n {\n case ZLIB_FILEFUNC_SEEK_CUR:\n new_pos = mem->cur_offset + offset;\n break;\n case ZLIB_FILEFUNC_SEEK_END:\n new_pos = mem->limit + offset;\n break;\n case ZLIB_FILEFUNC_SEEK_SET:\n new_pos = offset;\n break;\n default:\n return -1;\n }\n\n if (new_pos > mem->size)\n return 1; /* Failed to seek that far */\n mem->cur_offset = new_pos;\n return 0;\n}\n\nint ZCALLBACK fclose_mem_func(ZIP_UNUSED voidpf opaque, ZIP_UNUSED voidpf stream)\n{\n /* Even with grow = 1, caller must always free() memory */\n return 0;\n}\n\nint ZCALLBACK ferror_mem_func(ZIP_UNUSED voidpf opaque, ZIP_UNUSED voidpf stream)\n{\n /* We never return errors */\n return 0;\n}\n\nvoid fill_memory_filefunc(zlib_filefunc_def *pzlib_filefunc_def, ourmemory_t *ourmem)\n{\n pzlib_filefunc_def->zopen_file = fopen_mem_func;\n pzlib_filefunc_def->zopendisk_file = fopendisk_mem_func;\n pzlib_filefunc_def->zread_file = fread_mem_func;\n pzlib_filefunc_def->zwrite_file = fwrite_mem_func;\n pzlib_filefunc_def->ztell_file = ftell_mem_func;\n pzlib_filefunc_def->zseek_file = fseek_mem_func;\n pzlib_filefunc_def->zclose_file = fclose_mem_func;\n pzlib_filefunc_def->zerror_file = ferror_mem_func;\n pzlib_filefunc_def->opaque = ourmem;\n}\n"}}},{"rowIdx":22985,"cells":{"text":{"kind":"string","value":"/* ioapi_mem.h -- IO base function header for compress/uncompress .zip\n files using zlib + zip or unzip API\n\n This version of ioapi is designed to access memory rather than files.\n We do use a region of memory to put data in to and take it out of.\n\n Copyright (C) 2012-2017 Nathan Moinvaziri (https://github.com/nmoinvaz/minizip)\n (C) 2003 Justin Fletcher\n (C) 1998-2003 Gilles Vollant\n\n This program is distributed under the terms of the same license as zlib.\n See the accompanying LICENSE file for the full text of the license.\n*/\n\n#ifndef _IOAPI_MEM_H\n#define _IOAPI_MEM_H\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n#include \"zlib.h\"\n#include \"ioapi.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\nvoidpf ZCALLBACK fopen_mem_func(voidpf opaque, const char* filename, int mode);\nvoidpf ZCALLBACK fopendisk_mem_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode);\nuint32_t ZCALLBACK fread_mem_func(voidpf opaque, voidpf stream, void* buf, uint32_t size);\nuint32_t ZCALLBACK fwrite_mem_func(voidpf opaque, voidpf stream, const void* buf, uint32_t size);\nlong ZCALLBACK ftell_mem_func(voidpf opaque, voidpf stream);\nlong ZCALLBACK fseek_mem_func(voidpf opaque, voidpf stream, uint32_t offset, int origin);\nint ZCALLBACK fclose_mem_func(voidpf opaque, voidpf stream);\nint ZCALLBACK ferror_mem_func(voidpf opaque, voidpf stream);\n\ntypedef struct ourmemory_s {\n char *base; /* Base of the region of memory we're using */\n uint32_t size; /* Size of the region of memory we're using */\n uint32_t limit; /* Furthest we've written */\n uint32_t cur_offset; /* Current offset in the area */\n int grow; /* Growable memory buffer */\n} ourmemory_t;\n\nvoid fill_memory_filefunc(zlib_filefunc_def* pzlib_filefunc_def, ourmemory_t *ourmem);\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif\n"}}},{"rowIdx":22986,"cells":{"text":{"kind":"string","value":"/* unzip.c -- IO for uncompress .zip files using zlib\n Version 1.2.0, September 16th, 2017\n part of the MiniZip project\n\n Copyright (C) 2010-2017 Nathan Moinvaziri\n Modifications for AES, PKWARE disk spanning\n https://github.com/nmoinvaz/minizip\n Copyright (C) 2009-2010 Mathias Svensson\n Modifications for Zip64 support on both zip and unzip\n http://result42.com\n Copyright (C) 2007-2008 Even Rouault\n Modifications of Unzip for Zip64\n Copyright (C) 1998-2010 Gilles Vollant\n http://www.winimage.com/zLibDll/minizip.html\n\n This program is distributed under the terms of the same license as zlib.\n See the accompanying LICENSE file for the full text of the license.\n*/\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <stdint.h>\n#include <string.h>\n#include <limits.h>\n#include <errno.h>\n\n#include \"zlib.h\"\n#include \"unzip.h\"\n\n#ifdef HAVE_AES\n# define AES_METHOD (99)\n# define AES_PWVERIFYSIZE (2)\n# define AES_MAXSALTLENGTH (16)\n# define AES_AUTHCODESIZE (10)\n# define AES_HEADERSIZE (11)\n# define AES_KEYSIZE(mode) (64 + (mode * 64))\n\n# include \"aes/aes.h\"\n# include \"aes/fileenc.h\"\n#endif\n#ifdef HAVE_APPLE_COMPRESSION\n# include <compression.h>\n#endif\n\n#ifndef NOUNCRYPT\n# include \"crypt.h\"\n#endif\n\n#define DISKHEADERMAGIC (0x08074b50)\n#define LOCALHEADERMAGIC (0x04034b50)\n#define CENTRALHEADERMAGIC (0x02014b50)\n#define ENDHEADERMAGIC (0x06054b50)\n#define ZIP64ENDHEADERMAGIC (0x06064b50)\n#define ZIP64ENDLOCHEADERMAGIC (0x07064b50)\n\n#define SIZECENTRALDIRITEM (0x2e)\n#define SIZECENTRALHEADERLOCATOR (0x14)\n#define SIZEZIPLOCALHEADER (0x1e)\n\n#ifndef BUFREADCOMMENT\n# define BUFREADCOMMENT (0x400)\n#endif\n\n#ifndef UNZ_BUFSIZE\n# define UNZ_BUFSIZE (UINT16_MAX)\n#endif\n#ifndef UNZ_MAXFILENAMEINZIP\n# define UNZ_MAXFILENAMEINZIP (256)\n#endif\n\n#ifndef ALLOC\n# define ALLOC(size) (malloc(size))\n#endif\n#ifndef TRYFREE\n# define TRYFREE(p) {if (p) free(p);}\n#endif\n\nconst char unz_copyright[] = \" unzip 1.2.0 Copyright 1998-2017 - https://github.com/nmoinvaz/minizip\";\n\n/* unz_file_info_internal contain internal info about a file in zipfile*/\ntypedef struct unz_file_info64_internal_s\n{\n uint64_t offset_curfile; /* relative offset of local header 8 bytes */\n uint64_t byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx) */\n#ifdef HAVE_AES\n uint8_t aes_encryption_mode;\n uint16_t aes_compression_method;\n uint16_t aes_version;\n#endif\n} unz_file_info64_internal;\n\n/* file_in_zip_read_info_s contain internal information about a file in zipfile */\ntypedef struct\n{\n uint8_t *read_buffer; /* internal buffer for compressed data */\n z_stream stream; /* zLib stream structure for inflate */\n#ifdef HAVE_BZIP2\n bz_stream bstream; /* bzLib stream structure for bziped */\n#endif\n#ifdef HAVE_APPLE_COMPRESSION\n compression_stream astream; /* libcompression stream structure */\n#endif\n#ifdef HAVE_AES\n fcrypt_ctx aes_ctx;\n#endif\n uint64_t pos_in_zipfile; /* position in byte on the zipfile, for fseek */\n uint8_t stream_initialised; /* flag set if stream structure is initialised */\n\n uint64_t offset_local_extrafield; /* offset of the local extra field */\n uint16_t size_local_extrafield; /* size of the local extra field */\n uint64_t pos_local_extrafield; /* position in the local extra field in read */\n uint64_t total_out_64;\n\n uint32_t crc32; /* crc32 of all data uncompressed */\n uint32_t crc32_expected; /* crc32 we must obtain after decompress all */\n uint64_t rest_read_compressed; /* number of byte to be decompressed */\n uint64_t rest_read_uncompressed; /* number of byte to be obtained after decomp */\n\n zlib_filefunc64_32_def z_filefunc;\n\n voidpf filestream; /* io structore of the zipfile */\n uint16_t compression_method; /* compression method (0==store) */\n uint64_t byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx) */\n int raw;\n} file_in_zip64_read_info_s;\n\n/* unz64_s contain internal information about the zipfile */\ntypedef struct\n{\n zlib_filefunc64_32_def z_filefunc;\n\n voidpf filestream; /* io structure of the current zipfile */\n voidpf filestream_with_CD; /* io structure of the disk with the central directory */\n\n unz_global_info64 gi; /* public global information */\n\n uint64_t byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx) */\n uint64_t num_file; /* number of the current file in the zipfile */\n uint64_t pos_in_central_dir; /* pos of the current file in the central dir */\n uint64_t current_file_ok; /* flag about the usability of the current file */\n uint64_t central_pos; /* position of the beginning of the central dir */\n uint32_t number_disk; /* number of the current disk, used for spanning ZIP */\n uint64_t size_central_dir; /* size of the central directory */\n uint64_t offset_central_dir; /* offset of start of central directory with\n respect to the starting disk number */\n\n unz_file_info64 cur_file_info; /* public info about the current file in zip*/\n unz_file_info64_internal cur_file_info_internal;\n /* private info about it*/\n file_in_zip64_read_info_s *pfile_in_zip_read;\n /* structure about the current file if we are decompressing it */\n int is_zip64; /* is the current file zip64 */\n#ifndef NOUNCRYPT\n uint32_t keys[3]; /* keys defining the pseudo-random sequence */\n const z_crc_t *pcrc_32_tab;\n#endif\n} unz64_internal;\n\n/* Read a byte from a gz_stream; Return EOF for end of file. */\nstatic int unzReadUInt8(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint8_t *value)\n{\n uint8_t c = 0;\n if (ZREAD64(*pzlib_filefunc_def, filestream, &c, 1) == 1)\n {\n *value = (uint8_t)c;\n return UNZ_OK;\n }\n *value = 0;\n if (ZERROR64(*pzlib_filefunc_def, filestream))\n return UNZ_ERRNO;\n return UNZ_EOF;\n}\n\nstatic int unzReadUInt16(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint16_t *value)\n{\n uint16_t x;\n uint8_t c = 0;\n int err = UNZ_OK;\n\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &c);\n x = (uint16_t)c;\n if (err == UNZ_OK)\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &c);\n x |= ((uint16_t)c) << 8;\n\n if (err == UNZ_OK)\n *value = x;\n else\n *value = 0;\n return err;\n}\n\nstatic int unzReadUInt32(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint32_t *value)\n{\n uint32_t x = 0;\n uint8_t c = 0;\n int err = UNZ_OK;\n\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &c);\n x = (uint32_t)c;\n if (err == UNZ_OK)\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &c);\n x |= ((uint32_t)c) << 8;\n if (err == UNZ_OK)\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &c);\n x |= ((uint32_t)c) << 16;\n if (err == UNZ_OK)\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &c);\n x += ((uint32_t)c) << 24;\n\n if (err == UNZ_OK)\n *value = x;\n else\n *value = 0;\n return err;\n}\n\nstatic int unzReadUInt64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint64_t *value)\n{\n uint64_t x = 0;\n uint8_t i = 0;\n int err = UNZ_OK;\n\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);\n x = (uint64_t)i;\n if (err == UNZ_OK)\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);\n x |= ((uint64_t)i) << 8;\n if (err == UNZ_OK)\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);\n x |= ((uint64_t)i) << 16;\n if (err == UNZ_OK)\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);\n x |= ((uint64_t)i) << 24;\n if (err == UNZ_OK)\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);\n x |= ((uint64_t)i) << 32;\n if (err == UNZ_OK)\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);\n x |= ((uint64_t)i) << 40;\n if (err == UNZ_OK)\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);\n x |= ((uint64_t)i) << 48;\n if (err == UNZ_OK)\n err = unzReadUInt8(pzlib_filefunc_def, filestream, &i);\n x |= ((uint64_t)i) << 56;\n\n if (err == UNZ_OK)\n *value = x;\n else\n *value = 0;\n return err;\n}\n\n/* Locate the Central directory of a zip file (at the end, just before the global comment) */\nstatic int unzSearchCentralDir(const zlib_filefunc64_32_def *pzlib_filefunc_def, uint64_t *pos_found, voidpf filestream)\n{\n uint8_t buf[BUFREADCOMMENT + 4];\n uint64_t file_size = 0;\n uint64_t back_read = 4;\n uint64_t max_back = UINT16_MAX; /* maximum size of global comment */\n uint32_t read_size = 0;\n uint64_t read_pos = 0;\n uint32_t i = 0;\n *pos_found = 0;\n\n if (ZSEEK64(*pzlib_filefunc_def, filestream, 0, ZLIB_FILEFUNC_SEEK_END) != 0)\n return UNZ_ERRNO;\n\n file_size = ZTELL64(*pzlib_filefunc_def, filestream);\n\n if (max_back > file_size)\n max_back = file_size;\n\n while (back_read < max_back)\n {\n if (back_read + BUFREADCOMMENT > max_back)\n back_read = max_back;\n else\n back_read += BUFREADCOMMENT;\n\n read_pos = file_size - back_read;\n read_size = ((BUFREADCOMMENT + 4) < (file_size - read_pos)) ?\n (BUFREADCOMMENT + 4) : (uint32_t)(file_size - read_pos);\n\n if (ZSEEK64(*pzlib_filefunc_def, filestream, read_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)\n break;\n if (ZREAD64(*pzlib_filefunc_def, filestream, buf, read_size) != read_size)\n break;\n\n for (i = read_size - 3; (i--) > 0;)\n if (((*(buf+i)) == (ENDHEADERMAGIC & 0xff)) &&\n ((*(buf+i+1)) == (ENDHEADERMAGIC >> 8 & 0xff)) &&\n ((*(buf+i+2)) == (ENDHEADERMAGIC >> 16 & 0xff)) &&\n ((*(buf+i+3)) == (ENDHEADERMAGIC >> 24 & 0xff)))\n {\n *pos_found = read_pos+i;\n return UNZ_OK;\n }\n }\n\n return UNZ_ERRNO;\n}\n\n/* Locate the Central directory 64 of a zipfile (at the end, just before the global comment) */\nstatic int unzSearchCentralDir64(const zlib_filefunc64_32_def *pzlib_filefunc_def, uint64_t *offset, voidpf filestream,\n const uint64_t endcentraloffset)\n{\n uint32_t value32 = 0;\n *offset = 0;\n\n /* Zip64 end of central directory locator */\n if (ZSEEK64(*pzlib_filefunc_def, filestream, endcentraloffset - SIZECENTRALHEADERLOCATOR, ZLIB_FILEFUNC_SEEK_SET) != 0)\n return UNZ_ERRNO;\n\n /* Read locator signature */\n if (unzReadUInt32(pzlib_filefunc_def, filestream, &value32) != UNZ_OK)\n return UNZ_ERRNO;\n if (value32 != ZIP64ENDLOCHEADERMAGIC)\n return UNZ_ERRNO;\n /* Number of the disk with the start of the zip64 end of central directory */\n if (unzReadUInt32(pzlib_filefunc_def, filestream, &value32) != UNZ_OK)\n return UNZ_ERRNO;\n /* Relative offset of the zip64 end of central directory record */\n if (unzReadUInt64(pzlib_filefunc_def, filestream, offset) != UNZ_OK)\n return UNZ_ERRNO;\n /* Total number of disks */\n if (unzReadUInt32(pzlib_filefunc_def, filestream, &value32) != UNZ_OK)\n return UNZ_ERRNO;\n /* Goto end of central directory record */\n if (ZSEEK64(*pzlib_filefunc_def, filestream, *offset, ZLIB_FILEFUNC_SEEK_SET) != 0)\n return UNZ_ERRNO;\n /* The signature */\n if (unzReadUInt32(pzlib_filefunc_def, filestream, &value32) != UNZ_OK)\n return UNZ_ERRNO;\n if (value32 != ZIP64ENDHEADERMAGIC)\n return UNZ_ERRNO;\n\n return UNZ_OK;\n}\n\nstatic unzFile unzOpenInternal(const void *path, zlib_filefunc64_32_def *pzlib_filefunc64_32_def)\n{\n unz64_internal us;\n unz64_internal *s = NULL;\n uint64_t central_pos = 0;\n uint64_t central_pos64 = 0;\n uint64_t number_entry_CD = 0;\n uint16_t value16 = 0;\n uint32_t value32 = 0;\n uint64_t value64 = 0;\n voidpf filestream = NULL;\n int err = UNZ_OK;\n\n us.filestream = NULL;\n us.filestream_with_CD = NULL;\n us.z_filefunc.zseek32_file = NULL;\n us.z_filefunc.ztell32_file = NULL;\n\n if (pzlib_filefunc64_32_def == NULL)\n fill_fopen64_filefunc(&us.z_filefunc.zfile_func64);\n else\n us.z_filefunc = *pzlib_filefunc64_32_def;\n\n us.filestream = ZOPEN64(us.z_filefunc, path, ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING);\n\n if (us.filestream == NULL)\n return NULL;\n\n us.filestream_with_CD = us.filestream;\n us.is_zip64 = 0;\n\n /* Search for end of central directory header */\n err = unzSearchCentralDir(&us.z_filefunc, ¢ral_pos, us.filestream);\n if (err == UNZ_OK)\n {\n if (ZSEEK64(us.z_filefunc, us.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)\n err = UNZ_ERRNO;\n\n /* The signature, already checked */\n if (unzReadUInt32(&us.z_filefunc, us.filestream, &value32) != UNZ_OK)\n err = UNZ_ERRNO;\n /* Number of this disk */\n if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK)\n err = UNZ_ERRNO;\n us.number_disk = value16;\n /* Number of the disk with the start of the central directory */\n if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK)\n err = UNZ_ERRNO;\n us.gi.number_disk_with_CD = value16;\n /* Total number of entries in the central directory on this disk */\n if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK)\n err = UNZ_ERRNO;\n us.gi.number_entry = value16;\n /* Total number of entries in the central directory */\n if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK)\n err = UNZ_ERRNO;\n number_entry_CD = value16;\n if (number_entry_CD != us.gi.number_entry)\n err = UNZ_BADZIPFILE;\n /* Size of the central directory */\n if (unzReadUInt32(&us.z_filefunc, us.filestream, &value32) != UNZ_OK)\n err = UNZ_ERRNO;\n us.size_central_dir = value32;\n /* Offset of start of central directory with respect to the starting disk number */\n if (unzReadUInt32(&us.z_filefunc, us.filestream, &value32) != UNZ_OK)\n err = UNZ_ERRNO;\n us.offset_central_dir = value32;\n /* Zipfile comment length */\n if (unzReadUInt16(&us.z_filefunc, us.filestream, &us.gi.size_comment) != UNZ_OK)\n err = UNZ_ERRNO;\n\n if (err == UNZ_OK)\n {\n /* Search for Zip64 end of central directory header */\n int err64 = unzSearchCentralDir64(&us.z_filefunc, ¢ral_pos64, us.filestream, central_pos);\n if (err64 == UNZ_OK)\n {\n central_pos = central_pos64;\n us.is_zip64 = 1;\n\n if (ZSEEK64(us.z_filefunc, us.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)\n err = UNZ_ERRNO;\n\n /* the signature, already checked */\n if (unzReadUInt32(&us.z_filefunc, us.filestream, &value32) != UNZ_OK)\n err = UNZ_ERRNO;\n /* size of zip64 end of central directory record */\n if (unzReadUInt64(&us.z_filefunc, us.filestream, &value64) != UNZ_OK)\n err = UNZ_ERRNO;\n /* version made by */\n if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK)\n err = UNZ_ERRNO;\n /* version needed to extract */\n if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK)\n err = UNZ_ERRNO;\n /* number of this disk */\n if (unzReadUInt32(&us.z_filefunc, us.filestream, &us.number_disk) != UNZ_OK)\n err = UNZ_ERRNO;\n /* number of the disk with the start of the central directory */\n if (unzReadUInt32(&us.z_filefunc, us.filestream, &us.gi.number_disk_with_CD) != UNZ_OK)\n err = UNZ_ERRNO;\n /* total number of entries in the central directory on this disk */\n if (unzReadUInt64(&us.z_filefunc, us.filestream, &us.gi.number_entry) != UNZ_OK)\n err = UNZ_ERRNO;\n /* total number of entries in the central directory */\n if (unzReadUInt64(&us.z_filefunc, us.filestream, &number_entry_CD) != UNZ_OK)\n err = UNZ_ERRNO;\n if (number_entry_CD != us.gi.number_entry)\n err = UNZ_BADZIPFILE;\n /* size of the central directory */\n if (unzReadUInt64(&us.z_filefunc, us.filestream, &us.size_central_dir) != UNZ_OK)\n err = UNZ_ERRNO;\n /* offset of start of central directory with respect to the starting disk number */\n if (unzReadUInt64(&us.z_filefunc, us.filestream, &us.offset_central_dir) != UNZ_OK)\n err = UNZ_ERRNO;\n }\n else if ((us.gi.number_entry == UINT16_MAX) || (us.size_central_dir == UINT16_MAX) || (us.offset_central_dir == UINT32_MAX))\n err = UNZ_BADZIPFILE;\n }\n }\n else\n err = UNZ_ERRNO;\n\n if ((err == UNZ_OK) && (central_pos < us.offset_central_dir + us.size_central_dir))\n err = UNZ_BADZIPFILE;\n\n if (err != UNZ_OK)\n {\n ZCLOSE64(us.z_filefunc, us.filestream);\n return NULL;\n }\n\n if (us.gi.number_disk_with_CD == 0)\n {\n /* If there is only one disk open another stream so we don't have to seek between the CD\n and the file headers constantly */\n filestream = ZOPEN64(us.z_filefunc, path, ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING);\n if (filestream != NULL)\n us.filestream = filestream;\n }\n\n /* Hack for zip files that have no respect for zip64\n if ((central_pos > 0xffffffff) && (us.offset_central_dir < 0xffffffff))\n us.offset_central_dir = central_pos - us.size_central_dir;*/\n\n us.byte_before_the_zipfile = central_pos - (us.offset_central_dir + us.size_central_dir);\n us.central_pos = central_pos;\n us.pfile_in_zip_read = NULL;\n\n s = (unz64_internal*)ALLOC(sizeof(unz64_internal));\n if (s != NULL)\n {\n *s = us;\n unzGoToFirstFile((unzFile)s);\n }\n return (unzFile)s;\n}\n\nMZAPI unzFile unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc32_def)\n{\n if (pzlib_filefunc32_def != NULL)\n {\n zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;\n fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill, pzlib_filefunc32_def);\n return unzOpenInternal(path, &zlib_filefunc64_32_def_fill);\n }\n return unzOpenInternal(path, NULL);\n}\n\nMZAPI unzFile unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def)\n{\n if (pzlib_filefunc_def != NULL)\n {\n zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;\n zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;\n zlib_filefunc64_32_def_fill.ztell32_file = NULL;\n zlib_filefunc64_32_def_fill.zseek32_file = NULL;\n return unzOpenInternal(path, &zlib_filefunc64_32_def_fill);\n }\n return unzOpenInternal(path, NULL);\n}\n\nMZAPI unzFile unzOpen(const char *path)\n{\n return unzOpenInternal(path, NULL);\n}\n\nMZAPI unzFile unzOpen64(const void *path)\n{\n return unzOpenInternal(path, NULL);\n}\n\nMZAPI int unzClose(unzFile file)\n{\n unz64_internal *s;\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n\n if (s->pfile_in_zip_read != NULL)\n unzCloseCurrentFile(file);\n\n if ((s->filestream != NULL) && (s->filestream != s->filestream_with_CD))\n ZCLOSE64(s->z_filefunc, s->filestream);\n if (s->filestream_with_CD != NULL)\n ZCLOSE64(s->z_filefunc, s->filestream_with_CD);\n\n s->filestream = NULL;\n s->filestream_with_CD = NULL;\n TRYFREE(s);\n return UNZ_OK;\n}\n\n/* Goto to the next available disk for spanned archives */\nstatic int unzGoToNextDisk(unzFile file)\n{\n unz64_internal *s;\n uint32_t number_disk_next = 0;\n\n s = (unz64_internal*)file;\n if (s == NULL)\n return UNZ_PARAMERROR;\n number_disk_next = s->number_disk;\n\n if ((s->pfile_in_zip_read != NULL) && (s->pfile_in_zip_read->rest_read_uncompressed > 0))\n /* We are currently reading a file and we need the next sequential disk */\n number_disk_next += 1;\n else\n /* Goto the disk for the current file */\n number_disk_next = s->cur_file_info.disk_num_start;\n\n if (number_disk_next != s->number_disk)\n {\n /* Switch disks */\n if ((s->filestream != NULL) && (s->filestream != s->filestream_with_CD))\n ZCLOSE64(s->z_filefunc, s->filestream);\n\n if (number_disk_next == s->gi.number_disk_with_CD)\n {\n s->filestream = s->filestream_with_CD;\n }\n else\n {\n s->filestream = ZOPENDISK64(s->z_filefunc, s->filestream_with_CD, number_disk_next,\n ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING);\n }\n\n if (s->filestream == NULL)\n return UNZ_ERRNO;\n\n s->number_disk = number_disk_next;\n }\n\n return UNZ_OK;\n}\n\nMZAPI int unzGetGlobalInfo(unzFile file, unz_global_info* pglobal_info32)\n{\n unz64_internal *s = NULL;\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n\n pglobal_info32->number_entry = (uint32_t)s->gi.number_entry;\n pglobal_info32->size_comment = s->gi.size_comment;\n pglobal_info32->number_disk_with_CD = s->gi.number_disk_with_CD;\n return UNZ_OK;\n}\n\nMZAPI int unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info)\n{\n unz64_internal *s = NULL;\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n *pglobal_info = s->gi;\n return UNZ_OK;\n}\n\nMZAPI int unzGetGlobalComment(unzFile file, char *comment, uint16_t comment_size)\n{\n unz64_internal *s = NULL;\n uint16_t bytes_to_read = comment_size;\n if (file == NULL)\n return (int)UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n\n if (bytes_to_read > s->gi.size_comment)\n bytes_to_read = s->gi.size_comment;\n\n if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, s->central_pos + 22, ZLIB_FILEFUNC_SEEK_SET) != 0)\n return UNZ_ERRNO;\n\n if (bytes_to_read > 0)\n {\n *comment = 0;\n if (ZREAD64(s->z_filefunc, s->filestream_with_CD, comment, bytes_to_read) != bytes_to_read)\n return UNZ_ERRNO;\n }\n\n if ((comment != NULL) && (comment_size > s->gi.size_comment))\n *(comment + s->gi.size_comment) = 0;\n\n return (int)bytes_to_read;\n}\n\nstatic int unzGetCurrentFileInfoField(unzFile file, uint32_t *seek, void *field, uint16_t field_size, uint16_t size_file_field, int null_terminated_field)\n{\n unz64_internal *s = NULL;\n uint32_t bytes_to_read = 0;\n int err = UNZ_OK;\n\n if (file == NULL)\n return (int)UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n\n /* Read field */\n if (field != NULL)\n {\n if (size_file_field < field_size)\n {\n if (null_terminated_field)\n *((char *)field+size_file_field) = 0;\n\n bytes_to_read = size_file_field;\n }\n else\n bytes_to_read = field_size;\n \n if (*seek != 0)\n {\n if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, *seek, ZLIB_FILEFUNC_SEEK_CUR) == 0)\n *seek = 0;\n else\n err = UNZ_ERRNO;\n }\n \n if ((size_file_field > 0) && (field_size > 0))\n {\n if (ZREAD64(s->z_filefunc, s->filestream_with_CD, field, bytes_to_read) != bytes_to_read)\n err = UNZ_ERRNO;\n }\n *seek += size_file_field - bytes_to_read;\n }\n else\n {\n *seek += size_file_field;\n }\n\n return err;\n}\n\n/* Get info about the current file in the zipfile, with internal only info */\nstatic int unzGetCurrentFileInfoInternal(unzFile file, unz_file_info64 *pfile_info,\n unz_file_info64_internal *pfile_info_internal, char *filename, uint16_t filename_size, void *extrafield,\n uint16_t extrafield_size, char *comment, uint16_t comment_size)\n{\n unz64_internal *s = NULL;\n unz_file_info64 file_info;\n unz_file_info64_internal file_info_internal;\n uint32_t magic = 0;\n uint64_t current_pos = 0;\n uint32_t seek = 0;\n uint32_t extra_pos = 0;\n uint16_t extra_header_id = 0;\n uint16_t extra_data_size = 0;\n uint16_t value16 = 0;\n uint32_t value32 = 0;\n uint64_t value64 = 0;\n int err = UNZ_OK;\n\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n\n if (ZSEEK64(s->z_filefunc, s->filestream_with_CD,\n s->pos_in_central_dir + s->byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)\n err = UNZ_ERRNO;\n\n /* Check the magic */\n if (err == UNZ_OK)\n {\n if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &magic) != UNZ_OK)\n err = UNZ_ERRNO;\n else if (magic != CENTRALHEADERMAGIC)\n err = UNZ_BADZIPFILE;\n }\n\n /* Read central directory header */\n if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.version) != UNZ_OK)\n err = UNZ_ERRNO;\n if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.version_needed) != UNZ_OK)\n err = UNZ_ERRNO;\n if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.flag) != UNZ_OK)\n err = UNZ_ERRNO;\n if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.compression_method) != UNZ_OK)\n err = UNZ_ERRNO;\n if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &file_info.dos_date) != UNZ_OK)\n err = UNZ_ERRNO;\n if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &file_info.crc) != UNZ_OK)\n err = UNZ_ERRNO;\n if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &value32) != UNZ_OK)\n err = UNZ_ERRNO;\n file_info.compressed_size = value32;\n if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &value32) != UNZ_OK)\n err = UNZ_ERRNO;\n file_info.uncompressed_size = value32;\n if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.size_filename) != UNZ_OK)\n err = UNZ_ERRNO;\n if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.size_file_extra) != UNZ_OK)\n err = UNZ_ERRNO;\n if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.size_file_comment) != UNZ_OK)\n err = UNZ_ERRNO;\n if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &value16) != UNZ_OK)\n err = UNZ_ERRNO;\n file_info.disk_num_start = value16;\n if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.internal_fa) != UNZ_OK)\n err = UNZ_ERRNO;\n if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &file_info.external_fa) != UNZ_OK)\n err = UNZ_ERRNO;\n /* Relative offset of local header */\n if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &value32) != UNZ_OK)\n err = UNZ_ERRNO;\n\n file_info.size_file_extra_internal = 0;\n file_info.disk_offset = value32;\n file_info_internal.offset_curfile = value32;\n#ifdef HAVE_AES\n file_info_internal.aes_compression_method = 0;\n file_info_internal.aes_encryption_mode = 0;\n file_info_internal.aes_version = 0;\n#endif\n\n if (err == UNZ_OK)\n err = unzGetCurrentFileInfoField(file, &seek, filename, filename_size, file_info.size_filename, 1);\n\n /* Read extrafield */\n if (err == UNZ_OK)\n err = unzGetCurrentFileInfoField(file, &seek, extrafield, extrafield_size, file_info.size_file_extra, 0);\n\n if ((err == UNZ_OK) && (file_info.size_file_extra != 0))\n {\n if (seek != 0)\n {\n if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, seek, ZLIB_FILEFUNC_SEEK_CUR) == 0)\n seek = 0;\n else\n err = UNZ_ERRNO;\n }\n\n /* We are going to parse the extra field so we need to move back */\n current_pos = ZTELL64(s->z_filefunc, s->filestream_with_CD);\n if (current_pos < file_info.size_file_extra)\n err = UNZ_ERRNO;\n current_pos -= file_info.size_file_extra;\n if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, current_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)\n err = UNZ_ERRNO;\n\n while ((err != UNZ_ERRNO) && (extra_pos < file_info.size_file_extra))\n {\n if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &extra_header_id) != UNZ_OK)\n err = UNZ_ERRNO;\n if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &extra_data_size) != UNZ_OK)\n err = UNZ_ERRNO;\n\n /* ZIP64 extra fields */\n if (extra_header_id == 0x0001)\n {\n /* Subtract size of ZIP64 field, since ZIP64 is handled internally */\n file_info.size_file_extra_internal += 2 + 2 + extra_data_size;\n\n if (file_info.uncompressed_size == UINT32_MAX)\n {\n if (unzReadUInt64(&s->z_filefunc, s->filestream_with_CD, &file_info.uncompressed_size) != UNZ_OK)\n err = UNZ_ERRNO;\n }\n if (file_info.compressed_size == UINT32_MAX)\n {\n if (unzReadUInt64(&s->z_filefunc, s->filestream_with_CD, &file_info.compressed_size) != UNZ_OK)\n err = UNZ_ERRNO;\n }\n if (file_info_internal.offset_curfile == UINT32_MAX)\n {\n /* Relative Header offset */\n if (unzReadUInt64(&s->z_filefunc, s->filestream_with_CD, &value64) != UNZ_OK)\n err = UNZ_ERRNO;\n file_info_internal.offset_curfile = value64;\n file_info.disk_offset = value64;\n }\n if (file_info.disk_num_start == UINT32_MAX)\n {\n /* Disk Start Number */\n if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &file_info.disk_num_start) != UNZ_OK)\n err = UNZ_ERRNO;\n }\n }\n#ifdef HAVE_AES\n /* AES header */\n else if (extra_header_id == 0x9901)\n {\n uint8_t value8 = 0;\n\n /* Subtract size of AES field, since AES is handled internally */\n file_info.size_file_extra_internal += 2 + 2 + extra_data_size;\n\n /* Verify version info */\n if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &value16) != UNZ_OK)\n err = UNZ_ERRNO;\n /* Support AE-1 and AE-2 */\n if (value16 != 1 && value16 != 2)\n err = UNZ_ERRNO;\n file_info_internal.aes_version = value16;\n if (unzReadUInt8(&s->z_filefunc, s->filestream_with_CD, &value8) != UNZ_OK)\n err = UNZ_ERRNO;\n if ((char)value8 != 'A')\n err = UNZ_ERRNO;\n if (unzReadUInt8(&s->z_filefunc, s->filestream_with_CD, &value8) != UNZ_OK)\n err = UNZ_ERRNO;\n if ((char)value8 != 'E')\n err = UNZ_ERRNO;\n /* Get AES encryption strength and actual compression method */\n if (unzReadUInt8(&s->z_filefunc, s->filestream_with_CD, &value8) != UNZ_OK)\n err = UNZ_ERRNO;\n file_info_internal.aes_encryption_mode = value8;\n if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &value16) != UNZ_OK)\n err = UNZ_ERRNO;\n file_info_internal.aes_compression_method = value16;\n }\n#endif\n else\n {\n if (ZSEEK64(s->z_filefunc, s->filestream_with_CD,extra_data_size, ZLIB_FILEFUNC_SEEK_CUR) != 0)\n err = UNZ_ERRNO;\n }\n\n extra_pos += 2 + 2 + extra_data_size;\n }\n }\n\n if (file_info.disk_num_start == s->gi.number_disk_with_CD)\n file_info_internal.byte_before_the_zipfile = s->byte_before_the_zipfile;\n else\n file_info_internal.byte_before_the_zipfile = 0;\n\n if (err == UNZ_OK)\n err = unzGetCurrentFileInfoField(file, &seek, comment, comment_size, file_info.size_file_comment, 1);\n\n if ((err == UNZ_OK) && (pfile_info != NULL))\n *pfile_info = file_info;\n if ((err == UNZ_OK) && (pfile_info_internal != NULL))\n *pfile_info_internal = file_info_internal;\n\n return err;\n}\n\nMZAPI int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename,\n uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size)\n{\n unz_file_info64 file_info64;\n int err = UNZ_OK;\n\n err = unzGetCurrentFileInfoInternal(file, &file_info64, NULL, filename, filename_size,\n extrafield, extrafield_size, comment, comment_size);\n\n if ((err == UNZ_OK) && (pfile_info != NULL))\n {\n pfile_info->version = file_info64.version;\n pfile_info->version_needed = file_info64.version_needed;\n pfile_info->flag = file_info64.flag;\n pfile_info->compression_method = file_info64.compression_method;\n pfile_info->dos_date = file_info64.dos_date;\n pfile_info->crc = file_info64.crc;\n\n pfile_info->size_filename = file_info64.size_filename;\n pfile_info->size_file_extra = file_info64.size_file_extra - file_info64.size_file_extra_internal;\n pfile_info->size_file_comment = file_info64.size_file_comment;\n\n pfile_info->disk_num_start = (uint16_t)file_info64.disk_num_start;\n pfile_info->internal_fa = file_info64.internal_fa;\n pfile_info->external_fa = file_info64.external_fa;\n\n pfile_info->compressed_size = (uint32_t)file_info64.compressed_size;\n pfile_info->uncompressed_size = (uint32_t)file_info64.uncompressed_size;\n }\n return err;\n}\n\nMZAPI int unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *filename,\n uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size)\n{\n return unzGetCurrentFileInfoInternal(file, pfile_info, NULL, filename, filename_size,\n extrafield, extrafield_size, comment,comment_size);\n}\n\n/* Read the local header of the current zipfile. Check the coherency of the local header and info in the\n end of central directory about this file store in *piSizeVar the size of extra info in local header\n (filename and size of extra field data) */\nstatic int unzCheckCurrentFileCoherencyHeader(unz64_internal *s, uint32_t *psize_variable, uint64_t *poffset_local_extrafield,\n uint16_t *psize_local_extrafield)\n{\n uint32_t magic = 0;\n uint16_t value16 = 0;\n uint32_t value32 = 0;\n uint32_t flags = 0;\n uint16_t size_filename = 0;\n uint16_t size_extra_field = 0;\n uint16_t compression_method = 0;\n int err = UNZ_OK;\n\n if (psize_variable == NULL)\n return UNZ_PARAMERROR;\n *psize_variable = 0;\n if (poffset_local_extrafield == NULL)\n return UNZ_PARAMERROR;\n *poffset_local_extrafield = 0;\n if (psize_local_extrafield == NULL)\n return UNZ_PARAMERROR;\n *psize_local_extrafield = 0;\n\n err = unzGoToNextDisk((unzFile)s);\n if (err != UNZ_OK)\n return err;\n\n if (ZSEEK64(s->z_filefunc, s->filestream, s->cur_file_info_internal.offset_curfile +\n s->cur_file_info_internal.byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)\n return UNZ_ERRNO;\n\n if (err == UNZ_OK)\n {\n if (unzReadUInt32(&s->z_filefunc, s->filestream, &magic) != UNZ_OK)\n err = UNZ_ERRNO;\n else if (magic != LOCALHEADERMAGIC)\n err = UNZ_BADZIPFILE;\n }\n\n if (unzReadUInt16(&s->z_filefunc, s->filestream, &value16) != UNZ_OK)\n err = UNZ_ERRNO;\n if (unzReadUInt16(&s->z_filefunc, s->filestream, &value16) != UNZ_OK)\n err = UNZ_ERRNO;\n flags = value16;\n if (unzReadUInt16(&s->z_filefunc, s->filestream, &value16) != UNZ_OK)\n err = UNZ_ERRNO;\n else if ((err == UNZ_OK) && (value16 != s->cur_file_info.compression_method))\n err = UNZ_BADZIPFILE;\n\n compression_method = s->cur_file_info.compression_method;\n#ifdef HAVE_AES\n if (compression_method == AES_METHOD)\n compression_method = s->cur_file_info_internal.aes_compression_method;\n#endif\n\n if ((err == UNZ_OK) && (compression_method != 0) && (compression_method != Z_DEFLATED))\n {\n#ifdef HAVE_BZIP2\n if (compression_method != Z_BZIP2ED)\n#endif\n err = UNZ_BADZIPFILE;\n }\n\n if (unzReadUInt32(&s->z_filefunc, s->filestream, &value32) != UNZ_OK) /* date/time */\n err = UNZ_ERRNO;\n if (unzReadUInt32(&s->z_filefunc, s->filestream, &value32) != UNZ_OK) /* crc */\n err = UNZ_ERRNO;\n else if ((err == UNZ_OK) && (value32 != s->cur_file_info.crc) && ((flags & 8) == 0))\n err = UNZ_BADZIPFILE;\n if (unzReadUInt32(&s->z_filefunc, s->filestream, &value32) != UNZ_OK) /* size compr */\n err = UNZ_ERRNO;\n else if ((value32 != UINT32_MAX) && (err == UNZ_OK) && (value32 != s->cur_file_info.compressed_size) && ((flags & 8) == 0))\n err = UNZ_BADZIPFILE;\n if (unzReadUInt32(&s->z_filefunc, s->filestream, &value32) != UNZ_OK) /* size uncompr */\n err = UNZ_ERRNO;\n else if ((value32 != UINT32_MAX) && (err == UNZ_OK) && (value32 != s->cur_file_info.uncompressed_size) && ((flags & 8) == 0))\n err = UNZ_BADZIPFILE;\n if (unzReadUInt16(&s->z_filefunc, s->filestream, &size_filename) != UNZ_OK)\n err = UNZ_ERRNO;\n\n *psize_variable += size_filename;\n\n if (unzReadUInt16(&s->z_filefunc, s->filestream, &size_extra_field) != UNZ_OK)\n err = UNZ_ERRNO;\n\n *poffset_local_extrafield = s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + size_filename;\n *psize_local_extrafield = size_extra_field;\n *psize_variable += size_extra_field;\n\n return err;\n}\n\n/*\n Open for reading data the current file in the zipfile.\n If there is no error and the file is opened, the return value is UNZ_OK.\n*/\nMZAPI int unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password)\n{\n unz64_internal *s = NULL;\n file_in_zip64_read_info_s *pfile_in_zip_read_info = NULL;\n uint16_t compression_method = 0;\n uint64_t offset_local_extrafield = 0;\n uint16_t size_local_extrafield = 0;\n uint32_t size_variable = 0;\n int err = UNZ_OK;\n#ifndef NOUNCRYPT\n char source[12];\n#else\n if (password != NULL)\n return UNZ_PARAMERROR;\n#endif\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n if (!s->current_file_ok)\n return UNZ_PARAMERROR;\n\n if (s->pfile_in_zip_read != NULL)\n unzCloseCurrentFile(file);\n\n if (unzCheckCurrentFileCoherencyHeader(s, &size_variable, &offset_local_extrafield, &size_local_extrafield) != UNZ_OK)\n return UNZ_BADZIPFILE;\n \n compression_method = s->cur_file_info.compression_method;\n#ifdef HAVE_AES\n if (compression_method == AES_METHOD)\n {\n compression_method = s->cur_file_info_internal.aes_compression_method;\n if (password == NULL)\n {\n return UNZ_PARAMERROR;\n }\n }\n#endif\n\n if (method != NULL)\n *method = compression_method;\n\n if (level != NULL)\n {\n *level = 6;\n switch (s->cur_file_info.flag & 0x06)\n {\n case 6 : *level = 1; break;\n case 4 : *level = 2; break;\n case 2 : *level = 9; break;\n }\n }\n\n if ((compression_method != 0) && (compression_method != Z_DEFLATED))\n {\n#ifdef HAVE_BZIP2\n if (compression_method != Z_BZIP2ED)\n#endif\n {\n return UNZ_BADZIPFILE;\n }\n }\n \n pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s));\n if (pfile_in_zip_read_info == NULL)\n return UNZ_INTERNALERROR;\n\n pfile_in_zip_read_info->read_buffer = (uint8_t*)ALLOC(UNZ_BUFSIZE);\n if (pfile_in_zip_read_info->read_buffer == NULL)\n {\n TRYFREE(pfile_in_zip_read_info);\n return UNZ_INTERNALERROR;\n }\n \n pfile_in_zip_read_info->stream_initialised = 0;\n\n pfile_in_zip_read_info->filestream = s->filestream;\n pfile_in_zip_read_info->z_filefunc = s->z_filefunc;\n\n pfile_in_zip_read_info->raw = raw;\n pfile_in_zip_read_info->crc32 = 0;\n pfile_in_zip_read_info->crc32_expected = s->cur_file_info.crc;\n pfile_in_zip_read_info->total_out_64 = 0;\n pfile_in_zip_read_info->compression_method = compression_method;\n \n pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;\n pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;\n pfile_in_zip_read_info->pos_local_extrafield = 0;\n\n pfile_in_zip_read_info->rest_read_compressed = s->cur_file_info.compressed_size;\n pfile_in_zip_read_info->rest_read_uncompressed = s->cur_file_info.uncompressed_size;\n pfile_in_zip_read_info->byte_before_the_zipfile = 0;\n\n if (s->number_disk == s->gi.number_disk_with_CD)\n pfile_in_zip_read_info->byte_before_the_zipfile = s->byte_before_the_zipfile;\n \n pfile_in_zip_read_info->pos_in_zipfile = s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + size_variable;\n\n pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;\n pfile_in_zip_read_info->stream.zfree = (free_func)0;\n pfile_in_zip_read_info->stream.opaque = (voidpf)s;\n pfile_in_zip_read_info->stream.total_out = 0;\n pfile_in_zip_read_info->stream.total_in = 0;\n pfile_in_zip_read_info->stream.next_in = NULL;\n pfile_in_zip_read_info->stream.avail_in = 0;\n\n if (!raw)\n {\n if (compression_method == Z_BZIP2ED)\n {\n#ifdef HAVE_BZIP2\n pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0;\n pfile_in_zip_read_info->bstream.bzfree = (free_func)0;\n pfile_in_zip_read_info->bstream.opaque = (voidpf)0;\n pfile_in_zip_read_info->bstream.state = (voidpf)0;\n\n err = BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0);\n if (err == Z_OK)\n {\n pfile_in_zip_read_info->stream_initialised = Z_BZIP2ED;\n }\n else\n {\n TRYFREE(pfile_in_zip_read_info);\n return err;\n }\n#else\n pfile_in_zip_read_info->raw = 1;\n#endif\n }\n else if (compression_method == Z_DEFLATED)\n {\n#ifdef HAVE_APPLE_COMPRESSION\n err = compression_stream_init(&pfile_in_zip_read_info->astream, COMPRESSION_STREAM_DECODE, COMPRESSION_ZLIB);\n if (err == COMPRESSION_STATUS_ERROR)\n err = UNZ_INTERNALERROR;\n else\n err = Z_OK;\n#else\n err = inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);\n#endif\n if (err == Z_OK)\n {\n pfile_in_zip_read_info->stream_initialised = Z_DEFLATED;\n }\n else\n {\n TRYFREE(pfile_in_zip_read_info);\n return err;\n }\n /* windowBits is passed < 0 to tell that there is no zlib header.\n * Note that in this case inflate *requires* an extra \"dummy\" byte\n * after the compressed stream in order to complete decompression and\n * return Z_STREAM_END.\n * In unzip, i don't wait absolutely Z_STREAM_END because I known the\n * size of both compressed and uncompressed data\n */\n }\n }\n\n s->pfile_in_zip_read = pfile_in_zip_read_info;\n\n#ifndef NOUNCRYPT\n s->pcrc_32_tab = NULL;\n\n if ((password != NULL) && ((s->cur_file_info.flag & 1) != 0))\n {\n if (ZSEEK64(s->z_filefunc, s->filestream,\n s->pfile_in_zip_read->pos_in_zipfile + s->pfile_in_zip_read->byte_before_the_zipfile,\n ZLIB_FILEFUNC_SEEK_SET) != 0)\n return UNZ_INTERNALERROR;\n#ifdef HAVE_AES\n if (s->cur_file_info.compression_method == AES_METHOD)\n {\n unsigned char passverify_archive[AES_PWVERIFYSIZE];\n unsigned char passverify_password[AES_PWVERIFYSIZE];\n unsigned char salt_value[AES_MAXSALTLENGTH];\n uint32_t salt_length = 0;\n\n if ((s->cur_file_info_internal.aes_encryption_mode < 1) ||\n (s->cur_file_info_internal.aes_encryption_mode > 3))\n return UNZ_INTERNALERROR;\n\n salt_length = SALT_LENGTH(s->cur_file_info_internal.aes_encryption_mode);\n\n if (ZREAD64(s->z_filefunc, s->filestream, salt_value, salt_length) != salt_length)\n return UNZ_INTERNALERROR;\n if (ZREAD64(s->z_filefunc, s->filestream, passverify_archive, AES_PWVERIFYSIZE) != AES_PWVERIFYSIZE)\n return UNZ_INTERNALERROR;\n\n fcrypt_init(s->cur_file_info_internal.aes_encryption_mode, (uint8_t *)password,\n (uint32_t)strlen(password), salt_value, passverify_password, &s->pfile_in_zip_read->aes_ctx);\n\n if (memcmp(passverify_archive, passverify_password, AES_PWVERIFYSIZE) != 0)\n return UNZ_BADPASSWORD;\n\n s->pfile_in_zip_read->rest_read_compressed -= salt_length + AES_PWVERIFYSIZE;\n s->pfile_in_zip_read->rest_read_compressed -= AES_AUTHCODESIZE;\n\n s->pfile_in_zip_read->pos_in_zipfile += salt_length + AES_PWVERIFYSIZE;\n }\n else\n#endif\n {\n int i;\n uint8_t expected;\n uint8_t actual;\n \n s->pcrc_32_tab = (const z_crc_t*)get_crc_table();\n init_keys(password, s->keys, s->pcrc_32_tab);\n\n if (ZREAD64(s->z_filefunc, s->filestream, source, 12) < 12)\n return UNZ_INTERNALERROR;\n\n for (i = 0; i < 12; i++)\n zdecode(s->keys, s->pcrc_32_tab, source[i]);\n expected = (s->cur_file_info.flag & (1 << 3)) ?\n s->cur_file_info.dos_date >> 8 :\n s->cur_file_info.crc >> 24;\n actual = (uint8_t)source[11];\n if ((actual != 0) && (expected != actual)) {\n return UNZ_BADPASSWORD;\n }\n\n s->pfile_in_zip_read->rest_read_compressed -= 12;\n s->pfile_in_zip_read->pos_in_zipfile += 12;\n }\n }\n#endif\n\n return UNZ_OK;\n}\n\nMZAPI int unzOpenCurrentFile(unzFile file)\n{\n return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);\n}\n\nMZAPI int unzOpenCurrentFilePassword(unzFile file, const char *password)\n{\n return unzOpenCurrentFile3(file, NULL, NULL, 0, password);\n}\n\nMZAPI int unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw)\n{\n return unzOpenCurrentFile3(file, method, level, raw, NULL);\n}\n\n/* Read bytes from the current file.\n buf contain buffer where data must be copied\n len the size of buf.\n\n return the number of byte copied if some bytes are copied\n return 0 if the end of file was reached\n return <0 with error code if there is an error (UNZ_ERRNO for IO error, or zLib error for uncompress error) */\nMZAPI int unzReadCurrentFile(unzFile file, voidp buf, uint32_t len)\n{\n unz64_internal *s = NULL;\n uint32_t read = 0;\n int err = UNZ_OK;\n\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n\n if (s->pfile_in_zip_read == NULL)\n return UNZ_PARAMERROR;\n if (s->pfile_in_zip_read->read_buffer == NULL)\n return UNZ_END_OF_LIST_OF_FILE;\n if (len == 0)\n return 0;\n // avail_out is uInt, so uint32_t len might allow requesting a larger buffer than zlib can support\n if (len > UINT_MAX)\n return UNZ_PARAMERROR;\n\n s->pfile_in_zip_read->stream.next_out = (uint8_t*)buf;\n s->pfile_in_zip_read->stream.avail_out = (uInt)len;\n\n if ((s->pfile_in_zip_read->compression_method == 0) || (s->pfile_in_zip_read->raw))\n {\n if (len > s->pfile_in_zip_read->rest_read_compressed + s->pfile_in_zip_read->stream.avail_in)\n s->pfile_in_zip_read->stream.avail_out = (uInt)s->pfile_in_zip_read->rest_read_compressed +\n s->pfile_in_zip_read->stream.avail_in;\n }\n\n do\n {\n if (s->pfile_in_zip_read->stream.avail_in == 0)\n {\n uint32_t bytes_to_read = UNZ_BUFSIZE;\n uint32_t bytes_not_read = 0;\n uint32_t bytes_read = 0;\n uint32_t total_bytes_read = 0;\n\n if (s->pfile_in_zip_read->stream.next_in != NULL)\n bytes_not_read = (uint32_t)(s->pfile_in_zip_read->read_buffer + UNZ_BUFSIZE -\n s->pfile_in_zip_read->stream.next_in);\n bytes_to_read -= bytes_not_read;\n if (bytes_not_read > 0)\n memmove(s->pfile_in_zip_read->read_buffer, s->pfile_in_zip_read->stream.next_in, bytes_not_read);\n if (s->pfile_in_zip_read->rest_read_compressed < bytes_to_read)\n bytes_to_read = (uint32_t)s->pfile_in_zip_read->rest_read_compressed;\n\n while (total_bytes_read != bytes_to_read)\n {\n if (ZSEEK64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream,\n s->pfile_in_zip_read->pos_in_zipfile + s->pfile_in_zip_read->byte_before_the_zipfile,\n ZLIB_FILEFUNC_SEEK_SET) != 0)\n return UNZ_ERRNO;\n\n bytes_read = ZREAD64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream,\n s->pfile_in_zip_read->read_buffer + bytes_not_read + total_bytes_read,\n bytes_to_read - total_bytes_read);\n\n total_bytes_read += bytes_read;\n s->pfile_in_zip_read->pos_in_zipfile += bytes_read;\n\n if (bytes_read == 0)\n {\n if (ZERROR64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream))\n return UNZ_ERRNO;\n\n err = unzGoToNextDisk(file);\n if (err != UNZ_OK)\n return err;\n\n s->pfile_in_zip_read->pos_in_zipfile = 0;\n s->pfile_in_zip_read->filestream = s->filestream;\n }\n }\n\n#ifndef NOUNCRYPT\n if ((s->cur_file_info.flag & 1) != 0)\n {\n#ifdef HAVE_AES\n if (s->cur_file_info.compression_method == AES_METHOD)\n {\n fcrypt_decrypt(s->pfile_in_zip_read->read_buffer, bytes_to_read, &s->pfile_in_zip_read->aes_ctx);\n }\n else\n#endif\n if (s->pcrc_32_tab != NULL)\n {\n uint32_t i = 0;\n\n for (i = 0; i < total_bytes_read; i++)\n s->pfile_in_zip_read->read_buffer[i] =\n zdecode(s->keys, s->pcrc_32_tab, s->pfile_in_zip_read->read_buffer[i]);\n }\n }\n#endif\n\n s->pfile_in_zip_read->rest_read_compressed -= total_bytes_read;\n s->pfile_in_zip_read->stream.next_in = (uint8_t*)s->pfile_in_zip_read->read_buffer;\n s->pfile_in_zip_read->stream.avail_in = (uInt)(bytes_not_read + total_bytes_read);\n }\n\n if ((s->pfile_in_zip_read->compression_method == 0) || (s->pfile_in_zip_read->raw))\n {\n uint32_t n = 0;\n\n if ((s->pfile_in_zip_read->stream.avail_in == 0) &&\n (s->pfile_in_zip_read->rest_read_compressed == 0))\n return (read == 0) ? UNZ_EOF : read;\n\n if (s->pfile_in_zip_read->stream.avail_out < s->pfile_in_zip_read->stream.avail_in)\n n = s->pfile_in_zip_read->stream.avail_out;\n else\n n = s->pfile_in_zip_read->stream.avail_in;\n\n memcpy(s->pfile_in_zip_read->stream.next_out, s->pfile_in_zip_read->stream.next_in, n);\n\n s->pfile_in_zip_read->total_out_64 = s->pfile_in_zip_read->total_out_64 + n;\n s->pfile_in_zip_read->rest_read_uncompressed -= n;\n // s->pfile_in_zip_read->crc32 = (uint32_t)crc32(s->pfile_in_zip_read->crc32,\n // s->pfile_in_zip_read->stream.next_out, n);\n\n s->pfile_in_zip_read->stream.avail_in -= n;\n s->pfile_in_zip_read->stream.avail_out -= n;\n s->pfile_in_zip_read->stream.next_out += n;\n s->pfile_in_zip_read->stream.next_in += n;\n s->pfile_in_zip_read->stream.total_out += n;\n\n read += n;\n }\n else if (s->pfile_in_zip_read->compression_method == Z_BZIP2ED)\n {\n#ifdef HAVE_BZIP2\n uint64_t total_out_before = 0;\n uint64_t total_out_after = 0;\n uint64_t out_bytes = 0;\n const uint8_t *buf_before = NULL;\n\n s->pfile_in_zip_read->bstream.next_in = (char*)s->pfile_in_zip_read->stream.next_in;\n s->pfile_in_zip_read->bstream.avail_in = s->pfile_in_zip_read->stream.avail_in;\n s->pfile_in_zip_read->bstream.total_in_lo32 = (uint32_t)s->pfile_in_zip_read->stream.total_in;\n s->pfile_in_zip_read->bstream.total_in_hi32 = s->pfile_in_zip_read->stream.total_in >> 32;\n \n s->pfile_in_zip_read->bstream.next_out = (char*)s->pfile_in_zip_read->stream.next_out;\n s->pfile_in_zip_read->bstream.avail_out = s->pfile_in_zip_read->stream.avail_out;\n s->pfile_in_zip_read->bstream.total_out_lo32 = (uint32_t)s->pfile_in_zip_read->stream.total_out;\n s->pfile_in_zip_read->bstream.total_out_hi32 = s->pfile_in_zip_read->stream.total_out >> 32;\n\n total_out_before = s->pfile_in_zip_read->bstream.total_out_lo32 + \n (((uint32_t)s->pfile_in_zip_read->bstream.total_out_hi32) << 32);\n buf_before = (const uint8_t*)s->pfile_in_zip_read->bstream.next_out;\n\n err = BZ2_bzDecompress(&s->pfile_in_zip_read->bstream);\n\n total_out_after = s->pfile_in_zip_read->bstream.total_out_lo32 + \n (((uint32_t)s->pfile_in_zip_read->bstream.total_out_hi32) << 32);\n\n out_bytes = total_out_after - total_out_before;\n\n s->pfile_in_zip_read->total_out_64 = s->pfile_in_zip_read->total_out_64 + out_bytes;\n s->pfile_in_zip_read->rest_read_uncompressed -= out_bytes;\n // s->pfile_in_zip_read->crc32 = crc32(s->pfile_in_zip_read->crc32, buf_before, (uint32_t)out_bytes);\n\n read += (uint32_t)out_bytes;\n\n s->pfile_in_zip_read->stream.next_in = (uint8_t*)s->pfile_in_zip_read->bstream.next_in;\n s->pfile_in_zip_read->stream.avail_in = s->pfile_in_zip_read->bstream.avail_in;\n s->pfile_in_zip_read->stream.total_in = s->pfile_in_zip_read->bstream.total_in_lo32;\n s->pfile_in_zip_read->stream.next_out = (uint8_t*)s->pfile_in_zip_read->bstream.next_out;\n s->pfile_in_zip_read->stream.avail_out = s->pfile_in_zip_read->bstream.avail_out;\n s->pfile_in_zip_read->stream.total_out = s->pfile_in_zip_read->bstream.total_out_lo32;\n\n if (err == BZ_STREAM_END)\n return (read == 0) ? UNZ_EOF : read;\n if (err != BZ_OK)\n break;\n#endif\n }\n#ifdef HAVE_APPLE_COMPRESSION\n else\n {\n uint64_t total_out_before = 0;\n uint64_t total_out_after = 0;\n uint64_t out_bytes = 0;\n const uint8_t *buf_before = NULL;\n\n s->pfile_in_zip_read->astream.src_ptr = s->pfile_in_zip_read->stream.next_in;\n s->pfile_in_zip_read->astream.src_size = s->pfile_in_zip_read->stream.avail_in;\n s->pfile_in_zip_read->astream.dst_ptr = s->pfile_in_zip_read->stream.next_out;\n s->pfile_in_zip_read->astream.dst_size = len;\n\n total_out_before = s->pfile_in_zip_read->stream.total_out;\n buf_before = s->pfile_in_zip_read->stream.next_out;\n\n compression_status status;\n compression_stream_flags flags;\n\n if (s->pfile_in_zip_read->stream.avail_in == 0)\n {\n flags = COMPRESSION_STREAM_FINALIZE;\n }\n\n status = compression_stream_process(&s->pfile_in_zip_read->astream, flags);\n\n total_out_after = len - s->pfile_in_zip_read->astream.dst_size;\n out_bytes = total_out_after - total_out_before;\n\n s->pfile_in_zip_read->total_out_64 += out_bytes;\n s->pfile_in_zip_read->rest_read_uncompressed -= out_bytes;\n // s->pfile_in_zip_read->crc32 =\n // crc32(s->pfile_in_zip_read->crc32, buf_before, (uint32_t)out_bytes);\n\n read += (uint32_t)out_bytes;\n\n s->pfile_in_zip_read->stream.next_in = s->pfile_in_zip_read->astream.src_ptr;\n s->pfile_in_zip_read->stream.avail_in = s->pfile_in_zip_read->astream.src_size;\n s->pfile_in_zip_read->stream.next_out = s->pfile_in_zip_read->astream.dst_ptr;\n s->pfile_in_zip_read->stream.avail_out = s->pfile_in_zip_read->astream.dst_size;\n\n if (status == COMPRESSION_STATUS_END)\n return (read == 0) ? UNZ_EOF : read;\n if (status == COMPRESSION_STATUS_ERROR)\n return Z_DATA_ERROR;\n return read;\n }\n#else\n else\n {\n uint64_t total_out_before = 0;\n uint64_t total_out_after = 0;\n uint64_t out_bytes = 0;\n const uint8_t *buf_before = NULL;\n int flush = Z_SYNC_FLUSH;\n\n total_out_before = s->pfile_in_zip_read->stream.total_out;\n buf_before = s->pfile_in_zip_read->stream.next_out;\n\n /*\n if ((pfile_in_zip_read_info->rest_read_uncompressed ==\n pfile_in_zip_read_info->stream.avail_out) &&\n (pfile_in_zip_read_info->rest_read_compressed == 0))\n flush = Z_FINISH;\n */\n err = inflate(&s->pfile_in_zip_read->stream, flush);\n\n if ((err >= 0) && (s->pfile_in_zip_read->stream.msg != NULL))\n err = Z_DATA_ERROR;\n\n total_out_after = s->pfile_in_zip_read->stream.total_out;\n out_bytes = total_out_after - total_out_before;\n\n s->pfile_in_zip_read->total_out_64 += out_bytes;\n s->pfile_in_zip_read->rest_read_uncompressed -= out_bytes;\n // s->pfile_in_zip_read->crc32 =\n // (uint32_t)crc32(s->pfile_in_zip_read->crc32,buf_before, (uint32_t)out_bytes);\n\n read += (uint32_t)out_bytes;\n\n if (err == Z_STREAM_END)\n return (read == 0) ? UNZ_EOF : read;\n if (err != Z_OK)\n break;\n }\n#endif\n }\n while (s->pfile_in_zip_read->stream.avail_out > 0);\n\n if (err == Z_OK)\n return read;\n return err;\n}\n\nMZAPI int unzGetLocalExtrafield(unzFile file, voidp buf, uint32_t len)\n{\n unz64_internal *s = NULL;\n uint64_t size_to_read = 0;\n uint32_t read_now = 0;\n\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n if (s->pfile_in_zip_read == NULL)\n return UNZ_PARAMERROR;\n\n size_to_read = s->pfile_in_zip_read->size_local_extrafield - s->pfile_in_zip_read->pos_local_extrafield;\n\n if (buf == NULL)\n return (int)size_to_read;\n\n if (len > size_to_read)\n read_now = (uint32_t)size_to_read;\n else\n read_now = len;\n\n if (read_now == 0)\n return 0;\n\n if (ZSEEK64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream,\n s->pfile_in_zip_read->offset_local_extrafield + s->pfile_in_zip_read->pos_local_extrafield,\n ZLIB_FILEFUNC_SEEK_SET) != 0)\n return UNZ_ERRNO;\n\n if (ZREAD64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream, buf, read_now) != read_now)\n return UNZ_ERRNO;\n\n return (int)read_now;\n}\n\nMZAPI int unzCloseCurrentFile(unzFile file)\n{\n unz64_internal *s = NULL;\n file_in_zip64_read_info_s *pfile_in_zip_read_info = NULL;\n int err = UNZ_OK;\n\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n pfile_in_zip_read_info = s->pfile_in_zip_read;\n if (pfile_in_zip_read_info == NULL)\n return UNZ_PARAMERROR;\n\n#ifdef HAVE_AES\n if (s->cur_file_info.compression_method == AES_METHOD)\n {\n unsigned char authcode[AES_AUTHCODESIZE];\n unsigned char rauthcode[AES_AUTHCODESIZE];\n\n if (ZREAD64(s->z_filefunc, s->filestream, authcode, AES_AUTHCODESIZE) != AES_AUTHCODESIZE)\n return UNZ_ERRNO;\n\n if (fcrypt_end(rauthcode, &s->pfile_in_zip_read->aes_ctx) != AES_AUTHCODESIZE)\n err = UNZ_CRCERROR;\n if (memcmp(authcode, rauthcode, AES_AUTHCODESIZE) != 0)\n err = UNZ_CRCERROR;\n }\n /* AES zip version AE-1 will expect a valid crc as well */\n if ((s->cur_file_info.compression_method != AES_METHOD) ||\n (s->cur_file_info_internal.aes_version == 0x0001))\n#endif\n {\n if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&\n (!pfile_in_zip_read_info->raw))\n {\n if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_expected)\n err = UNZ_CRCERROR;\n }\n }\n\n TRYFREE(pfile_in_zip_read_info->read_buffer);\n pfile_in_zip_read_info->read_buffer = NULL;\n if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED)\n {\n#ifdef HAVE_APPLE_COMPRESSION\n if (compression_stream_destroy)\n compression_stream_destroy(&pfile_in_zip_read_info->astream);\n#else\n inflateEnd(&pfile_in_zip_read_info->stream);\n#endif\n \n }\n#ifdef HAVE_BZIP2\n else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED)\n BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream);\n#endif\n\n pfile_in_zip_read_info->stream_initialised = 0;\n TRYFREE(pfile_in_zip_read_info);\n\n s->pfile_in_zip_read = NULL;\n\n return err;\n}\n\nMZAPI int unzGoToFirstFile2(unzFile file, unz_file_info64 *pfile_info, char *filename,\n uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size)\n{\n unz64_internal *s = NULL;\n int err = UNZ_OK;\n\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n\n if (s->gi.number_entry == 0)\n return UNZ_END_OF_LIST_OF_FILE;\n\n s->pos_in_central_dir = s->offset_central_dir;\n s->num_file = 0;\n\n err = unzGetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal,\n filename, filename_size, extrafield, extrafield_size, comment,comment_size);\n\n s->current_file_ok = (err == UNZ_OK);\n if ((err == UNZ_OK) && (pfile_info != NULL))\n memcpy(pfile_info, &s->cur_file_info, sizeof(unz_file_info64));\n\n return err;\n}\n\nMZAPI int unzGoToFirstFile(unzFile file)\n{\n return unzGoToFirstFile2(file, NULL, NULL, 0, NULL, 0, NULL, 0);\n}\n\nMZAPI int unzGoToNextFile2(unzFile file, unz_file_info64 *pfile_info, char *filename,\n uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size)\n{\n unz64_internal *s = NULL;\n int err = UNZ_OK;\n\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n\n if (!s->current_file_ok)\n return UNZ_END_OF_LIST_OF_FILE;\n if (s->gi.number_entry != UINT16_MAX) /* 2^16 files overflow hack */\n {\n if (s->num_file+1 == s->gi.number_entry)\n return UNZ_END_OF_LIST_OF_FILE;\n }\n\n s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +\n s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment;\n s->num_file += 1;\n\n err = unzGetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal,\n filename, filename_size, extrafield,extrafield_size, comment, comment_size);\n\n s->current_file_ok = (err == UNZ_OK);\n if ((err == UNZ_OK) && (pfile_info != NULL))\n memcpy(pfile_info, &s->cur_file_info, sizeof(unz_file_info64));\n\n return err;\n}\n\nMZAPI int unzGoToNextFile(unzFile file)\n{\n return unzGoToNextFile2(file, NULL, NULL, 0, NULL, 0, NULL, 0);\n}\n\nMZAPI int unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func)\n{\n unz64_internal *s = NULL;\n unz_file_info64 cur_file_info_saved;\n unz_file_info64_internal cur_file_info_internal_saved;\n uint64_t num_file_saved = 0;\n uint64_t pos_in_central_dir_saved = 0;\n char current_filename[UNZ_MAXFILENAMEINZIP+1];\n int err = UNZ_OK;\n\n if (file == NULL)\n return UNZ_PARAMERROR;\n if (strlen(filename) >= UNZ_MAXFILENAMEINZIP)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n if (!s->current_file_ok)\n return UNZ_END_OF_LIST_OF_FILE;\n\n /* Save the current state */\n num_file_saved = s->num_file;\n pos_in_central_dir_saved = s->pos_in_central_dir;\n cur_file_info_saved = s->cur_file_info;\n cur_file_info_internal_saved = s->cur_file_info_internal;\n\n err = unzGoToFirstFile2(file, NULL, current_filename, sizeof(current_filename)-1, NULL, 0, NULL, 0);\n\n while (err == UNZ_OK)\n {\n if (filename_compare_func != NULL)\n err = filename_compare_func(file, current_filename, filename);\n else\n err = strcmp(current_filename, filename);\n if (err == 0)\n return UNZ_OK;\n err = unzGoToNextFile2(file, NULL, current_filename, sizeof(current_filename)-1, NULL, 0, NULL, 0);\n }\n\n /* We failed, so restore the state of the 'current file' to where we were. */\n s->num_file = num_file_saved;\n s->pos_in_central_dir = pos_in_central_dir_saved;\n s->cur_file_info = cur_file_info_saved;\n s->cur_file_info_internal = cur_file_info_internal_saved;\n return err;\n}\n\nMZAPI int unzGetFilePos(unzFile file, unz_file_pos *file_pos)\n{\n unz64_file_pos file_pos64;\n int err = unzGetFilePos64(file, &file_pos64);\n if (err == UNZ_OK)\n {\n file_pos->pos_in_zip_directory = (uint32_t)file_pos64.pos_in_zip_directory;\n file_pos->num_of_file = (uint32_t)file_pos64.num_of_file;\n }\n return err;\n}\n\nMZAPI int unzGoToFilePos(unzFile file, unz_file_pos *file_pos)\n{\n unz64_file_pos file_pos64;\n if (file_pos == NULL)\n return UNZ_PARAMERROR;\n file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;\n file_pos64.num_of_file = file_pos->num_of_file;\n return unzGoToFilePos64(file, &file_pos64);\n}\n\nMZAPI int unzGetFilePos64(unzFile file, unz64_file_pos *file_pos)\n{\n unz64_internal *s = NULL;\n\n if (file == NULL || file_pos == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n if (!s->current_file_ok)\n return UNZ_END_OF_LIST_OF_FILE;\n\n file_pos->pos_in_zip_directory = s->pos_in_central_dir;\n file_pos->num_of_file = s->num_file;\n return UNZ_OK;\n}\n\nMZAPI int unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos)\n{\n unz64_internal *s = NULL;\n int err = UNZ_OK;\n\n if (file == NULL || file_pos == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n\n /* Jump to the right spot */\n s->pos_in_central_dir = file_pos->pos_in_zip_directory;\n s->num_file = file_pos->num_of_file;\n\n /* Set the current file */\n err = unzGetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal, NULL, 0, NULL, 0, NULL, 0);\n /* Return results */\n s->current_file_ok = (err == UNZ_OK);\n return err;\n}\n\nMZAPI int32_t unzGetOffset(unzFile file)\n{\n uint64_t offset64 = 0;\n\n if (file == NULL)\n return UNZ_PARAMERROR;\n offset64 = unzGetOffset64(file);\n return (int32_t)offset64;\n}\n\nMZAPI int64_t unzGetOffset64(unzFile file)\n{\n unz64_internal *s = NULL;\n\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n if (!s->current_file_ok)\n return 0;\n if (s->gi.number_entry != 0 && s->gi.number_entry != UINT16_MAX)\n {\n if (s->num_file == s->gi.number_entry)\n return 0;\n }\n return s->pos_in_central_dir;\n}\n\nMZAPI int unzSetOffset(unzFile file, uint32_t pos)\n{\n return unzSetOffset64(file, pos);\n}\n\nMZAPI int unzSetOffset64(unzFile file, uint64_t pos)\n{\n unz64_internal *s = NULL;\n int err = UNZ_OK;\n\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n s->pos_in_central_dir = pos;\n s->num_file = s->gi.number_entry; /* hack */\n\n err = unzGetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal, NULL, 0, NULL, 0, NULL, 0);\n\n s->current_file_ok = (err == UNZ_OK);\n return err;\n}\n\nMZAPI int32_t unzTell(unzFile file)\n{\n unz64_internal *s = NULL;\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n if (s->pfile_in_zip_read == NULL)\n return UNZ_PARAMERROR;\n return (int32_t)s->pfile_in_zip_read->stream.total_out;\n}\n\nMZAPI int64_t unzTell64(unzFile file)\n{\n unz64_internal *s = NULL;\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n if (s->pfile_in_zip_read == NULL)\n return UNZ_PARAMERROR;\n return s->pfile_in_zip_read->total_out_64;\n}\n\nMZAPI int unzSeek(unzFile file, uint32_t offset, int origin)\n{\n return unzSeek64(file, offset, origin);\n}\n\nMZAPI int unzSeek64(unzFile file, uint64_t offset, int origin)\n{\n unz64_internal *s = NULL;\n uint64_t stream_pos_begin = 0;\n uint64_t stream_pos_end = 0;\n uint64_t position = 0;\n int is_within_buffer = 0;\n\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n\n if (s->pfile_in_zip_read == NULL)\n return UNZ_ERRNO;\n if (s->pfile_in_zip_read->compression_method != 0)\n return UNZ_ERRNO;\n\n if (origin == SEEK_SET)\n position = offset;\n else if (origin == SEEK_CUR)\n position = s->pfile_in_zip_read->total_out_64 + offset;\n else if (origin == SEEK_END)\n position = s->cur_file_info.compressed_size + offset;\n else\n return UNZ_PARAMERROR;\n\n if (position > s->cur_file_info.compressed_size)\n return UNZ_PARAMERROR;\n\n stream_pos_end = s->pfile_in_zip_read->pos_in_zipfile;\n stream_pos_begin = stream_pos_end;\n\n if (stream_pos_begin > UNZ_BUFSIZE)\n stream_pos_begin -= UNZ_BUFSIZE;\n else\n stream_pos_begin = 0;\n\n is_within_buffer = \n (s->pfile_in_zip_read->stream.avail_in != 0) &&\n (s->pfile_in_zip_read->rest_read_compressed != 0 || s->cur_file_info.compressed_size < UNZ_BUFSIZE) &&\n (position >= stream_pos_begin && position < stream_pos_end);\n\n if (is_within_buffer)\n {\n s->pfile_in_zip_read->stream.next_in += position - s->pfile_in_zip_read->total_out_64;\n s->pfile_in_zip_read->stream.avail_in = (uInt)(stream_pos_end - position);\n }\n else\n {\n s->pfile_in_zip_read->stream.avail_in = 0;\n s->pfile_in_zip_read->stream.next_in = 0;\n\n s->pfile_in_zip_read->pos_in_zipfile = s->pfile_in_zip_read->offset_local_extrafield + \n s->pfile_in_zip_read->size_local_extrafield + position;\n s->pfile_in_zip_read->rest_read_compressed = s->cur_file_info.compressed_size - position;\n }\n\n s->pfile_in_zip_read->rest_read_uncompressed -= (position - s->pfile_in_zip_read->total_out_64);\n s->pfile_in_zip_read->stream.total_out = (uint32_t)position;\n s->pfile_in_zip_read->total_out_64 = position;\n\n return UNZ_OK;\n}\n\nMZAPI int unzEndOfFile(unzFile file)\n{\n unz64_internal *s = NULL;\n if (file == NULL)\n return UNZ_PARAMERROR;\n s = (unz64_internal*)file;\n if (s->pfile_in_zip_read == NULL)\n return UNZ_PARAMERROR;\n if (s->pfile_in_zip_read->rest_read_uncompressed == 0)\n return 1;\n return 0;\n}\n"}}},{"rowIdx":22987,"cells":{"text":{"kind":"string","value":"/* unzip.h -- IO for uncompress .zip files using zlib\n Version 1.2.0, September 16th, 2017\n part of the MiniZip project\n\n Copyright (C) 2012-2017 Nathan Moinvaziri\n https://github.com/nmoinvaz/minizip\n Copyright (C) 2009-2010 Mathias Svensson\n Modifications for Zip64 support on both zip and unzip\n http://result42.com\n Copyright (C) 2007-2008 Even Rouault\n Modifications of Unzip for Zip64\n Copyright (C) 1998-2010 Gilles Vollant\n http://www.winimage.com/zLibDll/minizip.html\n\n This program is distributed under the terms of the same license as zlib.\n See the accompanying LICENSE file for the full text of the license.\n*/\n\n#ifndef _UNZ_H\n#define _UNZ_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#ifndef _ZLIB_H\n#include \"zlib.h\"\n#endif\n\n#ifndef _ZLIBIOAPI_H\n#include \"ioapi.h\"\n#endif\n\n#ifdef HAVE_BZIP2\n#include \"bzlib.h\"\n#endif\n\n#define MZAPI\n\n#define Z_BZIP2ED 12\n\n#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)\n/* like the STRICT of WIN32, we define a pointer that cannot be converted\n from (void*) without cast */\ntypedef struct TagunzFile__ { int unused; } unz_file__;\ntypedef unz_file__ *unzFile;\n#else\ntypedef voidp unzFile;\n#endif\n\n#define UNZ_OK (0)\n#define UNZ_END_OF_LIST_OF_FILE (-100)\n#define UNZ_ERRNO (Z_ERRNO)\n#define UNZ_EOF (0)\n#define UNZ_PARAMERROR (-102)\n#define UNZ_BADZIPFILE (-103)\n#define UNZ_INTERNALERROR (-104)\n#define UNZ_CRCERROR (-105)\n#define UNZ_BADPASSWORD (-106)\n\n/* unz_global_info structure contain global data about the ZIPfile\n These data comes from the end of central dir */\ntypedef struct unz_global_info64_s\n{\n uint64_t number_entry; /* total number of entries in the central dir on this disk */\n uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP*/\n uint16_t size_comment; /* size of the global comment of the zipfile */\n} unz_global_info64;\n\ntypedef struct unz_global_info_s\n{\n uint32_t number_entry; /* total number of entries in the central dir on this disk */\n uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP*/\n uint16_t size_comment; /* size of the global comment of the zipfile */\n} unz_global_info;\n\n/* unz_file_info contain information about a file in the zipfile */\ntypedef struct unz_file_info64_s\n{\n uint16_t version; /* version made by 2 bytes */\n uint16_t version_needed; /* version needed to extract 2 bytes */\n uint16_t flag; /* general purpose bit flag 2 bytes */\n uint16_t compression_method; /* compression method 2 bytes */\n uint32_t dos_date; /* last mod file date in Dos fmt 4 bytes */\n uint32_t crc; /* crc-32 4 bytes */\n uint64_t compressed_size; /* compressed size 8 bytes */\n uint64_t uncompressed_size; /* uncompressed size 8 bytes */\n uint16_t size_filename; /* filename length 2 bytes */\n uint16_t size_file_extra; /* extra field length 2 bytes */\n uint16_t size_file_comment; /* file comment length 2 bytes */\n\n uint32_t disk_num_start; /* disk number start 4 bytes */\n uint16_t internal_fa; /* internal file attributes 2 bytes */\n uint32_t external_fa; /* external file attributes 4 bytes */\n\n uint64_t disk_offset;\n\n uint16_t size_file_extra_internal;\n} unz_file_info64;\n\ntypedef struct unz_file_info_s\n{\n uint16_t version; /* version made by 2 bytes */\n uint16_t version_needed; /* version needed to extract 2 bytes */\n uint16_t flag; /* general purpose bit flag 2 bytes */\n uint16_t compression_method; /* compression method 2 bytes */\n uint32_t dos_date; /* last mod file date in Dos fmt 4 bytes */\n uint32_t crc; /* crc-32 4 bytes */\n uint32_t compressed_size; /* compressed size 4 bytes */\n uint32_t uncompressed_size; /* uncompressed size 4 bytes */\n uint16_t size_filename; /* filename length 2 bytes */\n uint16_t size_file_extra; /* extra field length 2 bytes */\n uint16_t size_file_comment; /* file comment length 2 bytes */\n\n uint16_t disk_num_start; /* disk number start 2 bytes */\n uint16_t internal_fa; /* internal file attributes 2 bytes */\n uint32_t external_fa; /* external file attributes 4 bytes */\n\n uint64_t disk_offset;\n} unz_file_info;\n\n/***************************************************************************/\n/* Opening and close a zip file */\n\nMZAPI unzFile unzOpen(const char *path);\nMZAPI unzFile unzOpen64(const void *path);\n/* Open a Zip file.\n\n path should contain the full path (by example, on a Windows XP computer \n \"c:\\\\zlib\\\\zlib113.zip\" or on an Unix computer \"zlib/zlib113.zip\". \n return NULL if zipfile cannot be opened or doesn't exist\n return unzFile handle if no error\n\n NOTE: The \"64\" function take a const void *pointer, because the path is just the value passed to the\n open64_file_func callback. Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path \n is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char *does not describe the reality */\n\nMZAPI unzFile unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc_def);\n/* Open a Zip file, like unzOpen, but provide a set of file low level API for read/write operations */\nMZAPI unzFile unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def);\n/* Open a Zip file, like unz64Open, but provide a set of file low level API for read/write 64-bit operations */\n\nMZAPI int unzClose(unzFile file);\n/* Close a ZipFile opened with unzOpen. If there is files inside the .Zip opened with unzOpenCurrentFile,\n these files MUST be closed with unzipCloseCurrentFile before call unzipClose.\n\n return UNZ_OK if there is no error */\n\nMZAPI int unzGetGlobalInfo(unzFile file, unz_global_info *pglobal_info);\nMZAPI int unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info);\n/* Write info about the ZipFile in the *pglobal_info structure.\n\n return UNZ_OK if no error */\n\nMZAPI int unzGetGlobalComment(unzFile file, char *comment, uint16_t comment_size);\n/* Get the global comment string of the ZipFile, in the comment buffer.\n\n uSizeBuf is the size of the szComment buffer.\n return the number of byte copied or an error code <0 */\n\n/***************************************************************************/\n/* Reading the content of the current zipfile, you can open it, read data from it, and close it\n (you can close it before reading all the file) */\n\nMZAPI int unzOpenCurrentFile(unzFile file);\n/* Open for reading data the current file in the zipfile.\n\n return UNZ_OK if no error */\n\nMZAPI int unzOpenCurrentFilePassword(unzFile file, const char *password);\n/* Open for reading data the current file in the zipfile.\n password is a crypting password\n\n return UNZ_OK if no error */\n\nMZAPI int unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw);\n/* Same as unzOpenCurrentFile, but open for read raw the file (not uncompress)\n if raw==1 *method will receive method of compression, *level will receive level of compression\n\n NOTE: you can set level parameter as NULL (if you did not want known level,\n but you CANNOT set method parameter as NULL */\n\nMZAPI int unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password);\n/* Same as unzOpenCurrentFile, but takes extra parameter password for encrypted files */\n\nMZAPI int unzReadCurrentFile(unzFile file, voidp buf, uint32_t len);\n/* Read bytes from the current file (opened by unzOpenCurrentFile)\n buf contain buffer where data must be copied\n len the size of buf.\n\n return the number of byte copied if somes bytes are copied\n return 0 if the end of file was reached\n return <0 with error code if there is an error (UNZ_ERRNO for IO error, or zLib error for uncompress error) */\n\nMZAPI int unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename, \n uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);\nMZAPI int unzGetCurrentFileInfo64(unzFile file, unz_file_info64 *pfile_info, char *filename,\n uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);\n/* Get Info about the current file\n\n pfile_info if != NULL, the *pfile_info structure will contain somes info about the current file\n filename if != NULL, the file name string will be copied in filename \n filename_size is the size of the filename buffer\n extrafield if != NULL, the extra field information from the central header will be copied in to\n extrafield_size is the size of the extraField buffer \n comment if != NULL, the comment string of the file will be copied in to\n comment_size is the size of the comment buffer */\n\nMZAPI int unzGetLocalExtrafield(unzFile file, voidp buf, uint32_t len);\n/* Read extra field from the current file (opened by unzOpenCurrentFile)\n This is the local-header version of the extra field (sometimes, there is\n more info in the local-header version than in the central-header)\n\n if buf == NULL, it return the size of the local extra field\n if buf != NULL, len is the size of the buffer, the extra header is copied in buf.\n\n return number of bytes copied in buf, or (if <0) the error code */\n\nMZAPI int unzCloseCurrentFile(unzFile file);\n/* Close the file in zip opened with unzOpenCurrentFile\n\n return UNZ_CRCERROR if all the file was read but the CRC is not good */\n\n/***************************************************************************/\n/* Browse the directory of the zipfile */\n\ntypedef int (*unzFileNameComparer)(unzFile file, const char *filename1, const char *filename2);\ntypedef int (*unzIteratorFunction)(unzFile file);\ntypedef int (*unzIteratorFunction2)(unzFile file, unz_file_info64 *pfile_info, char *filename,\n uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);\n\nMZAPI int unzGoToFirstFile(unzFile file);\n/* Set the current file of the zipfile to the first file.\n\n return UNZ_OK if no error */\n\nMZAPI int unzGoToFirstFile2(unzFile file, unz_file_info64 *pfile_info, char *filename,\n uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);\n/* Set the current file of the zipfile to the first file and retrieves the current info on success. \n Not as seek intensive as unzGoToFirstFile + unzGetCurrentFileInfo.\n\n return UNZ_OK if no error */\n\nMZAPI int unzGoToNextFile(unzFile file);\n/* Set the current file of the zipfile to the next file.\n\n return UNZ_OK if no error\n return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */\n\nMZAPI int unzGoToNextFile2(unzFile file, unz_file_info64 *pfile_info, char *filename,\n uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);\n/* Set the current file of the zipfile to the next file and retrieves the current \n info on success. Does less seeking around than unzGotoNextFile + unzGetCurrentFileInfo.\n\n return UNZ_OK if no error\n return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */\n\nMZAPI int unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func);\n/* Try locate the file szFileName in the zipfile. For custom filename comparison pass in comparison function.\n\n return UNZ_OK if the file is found (it becomes the current file)\n return UNZ_END_OF_LIST_OF_FILE if the file is not found */\n\n/***************************************************************************/\n/* Raw access to zip file */\n\ntypedef struct unz_file_pos_s\n{\n uint32_t pos_in_zip_directory; /* offset in zip file directory */\n uint32_t num_of_file; /* # of file */\n} unz_file_pos;\n\nMZAPI int unzGetFilePos(unzFile file, unz_file_pos *file_pos);\nMZAPI int unzGoToFilePos(unzFile file, unz_file_pos *file_pos);\n\ntypedef struct unz64_file_pos_s\n{\n uint64_t pos_in_zip_directory; /* offset in zip file directory */\n uint64_t num_of_file; /* # of file */\n} unz64_file_pos;\n\nMZAPI int unzGetFilePos64(unzFile file, unz64_file_pos *file_pos);\nMZAPI int unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos);\n\nMZAPI int32_t unzGetOffset(unzFile file);\nMZAPI int64_t unzGetOffset64(unzFile file);\n/* Get the current file offset */\n\nMZAPI int unzSetOffset(unzFile file, uint32_t pos);\nMZAPI int unzSetOffset64(unzFile file, uint64_t pos);\n/* Set the current file offset */\n\nMZAPI int32_t unzTell(unzFile file);\nMZAPI int64_t unzTell64(unzFile file);\n/* return current position in uncompressed data */\n\nMZAPI int unzSeek(unzFile file, uint32_t offset, int origin);\nMZAPI int unzSeek64(unzFile file, uint64_t offset, int origin);\n/* Seek within the uncompressed data if compression method is storage */\n\nMZAPI int unzEndOfFile(unzFile file);\n/* return 1 if the end of file was reached, 0 elsewhere */\n\n/***************************************************************************/\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif /* _UNZ_H */\n"}}},{"rowIdx":22988,"cells":{"text":{"kind":"string","value":"// Copyright 2022 Google Inc. All Rights Reserved.\n//\n// Use of this source code is governed by a BSD-style license\n// that can be found in the COPYING file in the root of the source\n// tree. An additional intellectual property rights grant can be found\n// in the file PATENTS. All contributing project authors may\n// be found in the AUTHORS file in the root of the source tree.\n// -----------------------------------------------------------------------------\n//\n// Sharp RGB to YUV conversion.\n//\n// Author: Skal (pascal.massimino@gmail.com)\n\n#include \"sharpyuv/sharpyuv.h\"\n\n#include <assert.h>\n#include <limits.h>\n#include <stddef.h>\n#include <stdlib.h>\n#include <string.h>\n\n#include \"sharpyuv/sharpyuv_cpu.h\"\n#include \"sharpyuv/sharpyuv_dsp.h\"\n#include \"sharpyuv/sharpyuv_gamma.h\"\n#include \"src/webp/types.h\"\n\n//------------------------------------------------------------------------------\n\nint SharpYuvGetVersion(void) {\n return SHARPYUV_VERSION;\n}\n\n//------------------------------------------------------------------------------\n// Sharp RGB->YUV conversion\n\nstatic const int kNumIterations = 4;\n\n#define YUV_FIX 16 // fixed-point precision for RGB->YUV\nstatic const int kYuvHalf = 1 << (YUV_FIX - 1);\n\n// Max bit depth so that intermediate calculations fit in 16 bits.\nstatic const int kMaxBitDepth = 14;\n\n// Returns the precision shift to use based on the input rgb_bit_depth.\nstatic int GetPrecisionShift(int rgb_bit_depth) {\n // Try to add 2 bits of precision if it fits in kMaxBitDepth. Otherwise remove\n // bits if needed.\n return ((rgb_bit_depth + 2) <= kMaxBitDepth) ? 2\n : (kMaxBitDepth - rgb_bit_depth);\n}\n\ntypedef int16_t fixed_t; // signed type with extra precision for UV\ntypedef uint16_t fixed_y_t; // unsigned type with extra precision for W\n\n//------------------------------------------------------------------------------\n\nstatic uint8_t clip_8b(fixed_t v) {\n return (!(v & ~0xff)) ? (uint8_t)v : (v < 0) ? 0u : 255u;\n}\n\nstatic uint16_t clip(fixed_t v, int max) {\n return (v < 0) ? 0 : (v > max) ? max : (uint16_t)v;\n}\n\nstatic fixed_y_t clip_bit_depth(int y, int bit_depth) {\n const int max = (1 << bit_depth) - 1;\n return (!(y & ~max)) ? (fixed_y_t)y : (y < 0) ? 0 : max;\n}\n\n//------------------------------------------------------------------------------\n\nstatic int RGBToGray(int64_t r, int64_t g, int64_t b) {\n const int64_t luma = 13933 * r + 46871 * g + 4732 * b + kYuvHalf;\n return (int)(luma >> YUV_FIX);\n}\n\nstatic uint32_t ScaleDown(uint16_t a, uint16_t b, uint16_t c, uint16_t d,\n int rgb_bit_depth,\n SharpYuvTransferFunctionType transfer_type) {\n const int bit_depth = rgb_bit_depth + GetPrecisionShift(rgb_bit_depth);\n const uint32_t A = SharpYuvGammaToLinear(a, bit_depth, transfer_type);\n const uint32_t B = SharpYuvGammaToLinear(b, bit_depth, transfer_type);\n const uint32_t C = SharpYuvGammaToLinear(c, bit_depth, transfer_type);\n const uint32_t D = SharpYuvGammaToLinear(d, bit_depth, transfer_type);\n return SharpYuvLinearToGamma((A + B + C + D + 2) >> 2, bit_depth,\n transfer_type);\n}\n\nstatic WEBP_INLINE void UpdateW(const fixed_y_t* src, fixed_y_t* dst, int w,\n int rgb_bit_depth,\n SharpYuvTransferFunctionType transfer_type) {\n const int bit_depth = rgb_bit_depth + GetPrecisionShift(rgb_bit_depth);\n int i = 0;\n do {\n const uint32_t R =\n SharpYuvGammaToLinear(src[0 * w + i], bit_depth, transfer_type);\n const uint32_t G =\n SharpYuvGammaToLinear(src[1 * w + i], bit_depth, transfer_type);\n const uint32_t B =\n SharpYuvGammaToLinear(src[2 * w + i], bit_depth, transfer_type);\n const uint32_t Y = RGBToGray(R, G, B);\n dst[i] = (fixed_y_t)SharpYuvLinearToGamma(Y, bit_depth, transfer_type);\n } while (++i < w);\n}\n\nstatic void UpdateChroma(const fixed_y_t* src1, const fixed_y_t* src2,\n fixed_t* dst, int uv_w, int rgb_bit_depth,\n SharpYuvTransferFunctionType transfer_type) {\n int i = 0;\n do {\n const int r =\n ScaleDown(src1[0 * uv_w + 0], src1[0 * uv_w + 1], src2[0 * uv_w + 0],\n src2[0 * uv_w + 1], rgb_bit_depth, transfer_type);\n const int g =\n ScaleDown(src1[2 * uv_w + 0], src1[2 * uv_w + 1], src2[2 * uv_w + 0],\n src2[2 * uv_w + 1], rgb_bit_depth, transfer_type);\n const int b =\n ScaleDown(src1[4 * uv_w + 0], src1[4 * uv_w + 1], src2[4 * uv_w + 0],\n src2[4 * uv_w + 1], rgb_bit_depth, transfer_type);\n const int W = RGBToGray(r, g, b);\n dst[0 * uv_w] = (fixed_t)(r - W);\n dst[1 * uv_w] = (fixed_t)(g - W);\n dst[2 * uv_w] = (fixed_t)(b - W);\n dst += 1;\n src1 += 2;\n src2 += 2;\n } while (++i < uv_w);\n}\n\nstatic void StoreGray(const fixed_y_t* rgb, fixed_y_t* y, int w) {\n int i = 0;\n assert(w > 0);\n do {\n y[i] = RGBToGray(rgb[0 * w + i], rgb[1 * w + i], rgb[2 * w + i]);\n } while (++i < w);\n}\n\n//------------------------------------------------------------------------------\n\nstatic WEBP_INLINE fixed_y_t Filter2(int A, int B, int W0, int bit_depth) {\n const int v0 = (A * 3 + B + 2) >> 2;\n return clip_bit_depth(v0 + W0, bit_depth);\n}\n\n//------------------------------------------------------------------------------\n\nstatic WEBP_INLINE int Shift(int v, int shift) {\n return (shift >= 0) ? (v << shift) : (v >> -shift);\n}\n\nstatic void ImportOneRow(const uint8_t* const r_ptr,\n const uint8_t* const g_ptr,\n const uint8_t* const b_ptr,\n int rgb_step,\n int rgb_bit_depth,\n int pic_width,\n fixed_y_t* const dst) {\n // Convert the rgb_step from a number of bytes to a number of uint8_t or\n // uint16_t values depending the bit depth.\n const int step = (rgb_bit_depth > 8) ? rgb_step / 2 : rgb_step;\n int i = 0;\n const int w = (pic_width + 1) & ~1;\n do {\n const int off = i * step;\n const int shift = GetPrecisionShift(rgb_bit_depth);\n if (rgb_bit_depth == 8) {\n dst[i + 0 * w] = Shift(r_ptr[off], shift);\n dst[i + 1 * w] = Shift(g_ptr[off], shift);\n dst[i + 2 * w] = Shift(b_ptr[off], shift);\n } else {\n dst[i + 0 * w] = Shift(((uint16_t*)r_ptr)[off], shift);\n dst[i + 1 * w] = Shift(((uint16_t*)g_ptr)[off], shift);\n dst[i + 2 * w] = Shift(((uint16_t*)b_ptr)[off], shift);\n }\n } while (++i < pic_width);\n if (pic_width & 1) { // replicate rightmost pixel\n dst[pic_width + 0 * w] = dst[pic_width + 0 * w - 1];\n dst[pic_width + 1 * w] = dst[pic_width + 1 * w - 1];\n dst[pic_width + 2 * w] = dst[pic_width + 2 * w - 1];\n }\n}\n\nstatic void InterpolateTwoRows(const fixed_y_t* const best_y,\n const fixed_t* prev_uv,\n const fixed_t* cur_uv,\n const fixed_t* next_uv,\n int w,\n fixed_y_t* out1,\n fixed_y_t* out2,\n int rgb_bit_depth) {\n const int uv_w = w >> 1;\n const int len = (w - 1) >> 1; // length to filter\n int k = 3;\n const int bit_depth = rgb_bit_depth + GetPrecisionShift(rgb_bit_depth);\n while (k-- > 0) { // process each R/G/B segments in turn\n // special boundary case for i==0\n out1[0] = Filter2(cur_uv[0], prev_uv[0], best_y[0], bit_depth);\n out2[0] = Filter2(cur_uv[0], next_uv[0], best_y[w], bit_depth);\n\n SharpYuvFilterRow(cur_uv, prev_uv, len, best_y + 0 + 1, out1 + 1,\n bit_depth);\n SharpYuvFilterRow(cur_uv, next_uv, len, best_y + w + 1, out2 + 1,\n bit_depth);\n\n // special boundary case for i == w - 1 when w is even\n if (!(w & 1)) {\n out1[w - 1] = Filter2(cur_uv[uv_w - 1], prev_uv[uv_w - 1],\n best_y[w - 1 + 0], bit_depth);\n out2[w - 1] = Filter2(cur_uv[uv_w - 1], next_uv[uv_w - 1],\n best_y[w - 1 + w], bit_depth);\n }\n out1 += w;\n out2 += w;\n prev_uv += uv_w;\n cur_uv += uv_w;\n next_uv += uv_w;\n }\n}\n\nstatic WEBP_INLINE int RGBToYUVComponent(int r, int g, int b,\n const int coeffs[4], int sfix) {\n const int srounder = 1 << (YUV_FIX + sfix - 1);\n const int luma = coeffs[0] * r + coeffs[1] * g + coeffs[2] * b +\n coeffs[3] + srounder;\n return (luma >> (YUV_FIX + sfix));\n}\n\nstatic int ConvertWRGBToYUV(const fixed_y_t* best_y, const fixed_t* best_uv,\n uint8_t* y_ptr, int y_stride, uint8_t* u_ptr,\n int u_stride, uint8_t* v_ptr, int v_stride,\n int rgb_bit_depth,\n int yuv_bit_depth, int width, int height,\n const SharpYuvConversionMatrix* yuv_matrix) {\n int i, j;\n const fixed_t* const best_uv_base = best_uv;\n const int w = (width + 1) & ~1;\n const int h = (height + 1) & ~1;\n const int uv_w = w >> 1;\n const int uv_h = h >> 1;\n const int sfix = GetPrecisionShift(rgb_bit_depth);\n const int yuv_max = (1 << yuv_bit_depth) - 1;\n\n best_uv = best_uv_base;\n j = 0;\n do {\n i = 0;\n do {\n const int off = (i >> 1);\n const int W = best_y[i];\n const int r = best_uv[off + 0 * uv_w] + W;\n const int g = best_uv[off + 1 * uv_w] + W;\n const int b = best_uv[off + 2 * uv_w] + W;\n const int y = RGBToYUVComponent(r, g, b, yuv_matrix->rgb_to_y, sfix);\n if (yuv_bit_depth <= 8) {\n y_ptr[i] = clip_8b(y);\n } else {\n ((uint16_t*)y_ptr)[i] = clip(y, yuv_max);\n }\n } while (++i < width);\n best_y += w;\n best_uv += (j & 1) * 3 * uv_w;\n y_ptr += y_stride;\n } while (++j < height);\n\n best_uv = best_uv_base;\n j = 0;\n do {\n i = 0;\n do {\n // Note r, g and b values here are off by W, but a constant offset on all\n // 3 components doesn't change the value of u and v with a YCbCr matrix.\n const int r = best_uv[i + 0 * uv_w];\n const int g = best_uv[i + 1 * uv_w];\n const int b = best_uv[i + 2 * uv_w];\n const int u = RGBToYUVComponent(r, g, b, yuv_matrix->rgb_to_u, sfix);\n const int v = RGBToYUVComponent(r, g, b, yuv_matrix->rgb_to_v, sfix);\n if (yuv_bit_depth <= 8) {\n u_ptr[i] = clip_8b(u);\n v_ptr[i] = clip_8b(v);\n } else {\n ((uint16_t*)u_ptr)[i] = clip(u, yuv_max);\n ((uint16_t*)v_ptr)[i] = clip(v, yuv_max);\n }\n } while (++i < uv_w);\n best_uv += 3 * uv_w;\n u_ptr += u_stride;\n v_ptr += v_stride;\n } while (++j < uv_h);\n return 1;\n}\n\n//------------------------------------------------------------------------------\n// Main function\n\nstatic void* SafeMalloc(uint64_t nmemb, size_t size) {\n const uint64_t total_size = nmemb * (uint64_t)size;\n if (total_size != (size_t)total_size) return NULL;\n return malloc((size_t)total_size);\n}\n\n#define SAFE_ALLOC(W, H, T) ((T*)SafeMalloc((uint64_t)(W) * (H), sizeof(T)))\n\nstatic int DoSharpArgbToYuv(const uint8_t* r_ptr, const uint8_t* g_ptr,\n const uint8_t* b_ptr, int rgb_step, int rgb_stride,\n int rgb_bit_depth, uint8_t* y_ptr, int y_stride,\n uint8_t* u_ptr, int u_stride, uint8_t* v_ptr,\n int v_stride, int yuv_bit_depth, int width,\n int height,\n const SharpYuvConversionMatrix* yuv_matrix,\n SharpYuvTransferFunctionType transfer_type) {\n // we expand the right/bottom border if needed\n const int w = (width + 1) & ~1;\n const int h = (height + 1) & ~1;\n const int uv_w = w >> 1;\n const int uv_h = h >> 1;\n const int y_bit_depth = rgb_bit_depth + GetPrecisionShift(rgb_bit_depth);\n uint64_t prev_diff_y_sum = ~0;\n int j, iter;\n\n // TODO(skal): allocate one big memory chunk. But for now, it's easier\n // for valgrind debugging to have several chunks.\n fixed_y_t* const tmp_buffer = SAFE_ALLOC(w * 3, 2, fixed_y_t); // scratch\n fixed_y_t* const best_y_base = SAFE_ALLOC(w, h, fixed_y_t);\n fixed_y_t* const target_y_base = SAFE_ALLOC(w, h, fixed_y_t);\n fixed_y_t* const best_rgb_y = SAFE_ALLOC(w, 2, fixed_y_t);\n fixed_t* const best_uv_base = SAFE_ALLOC(uv_w * 3, uv_h, fixed_t);\n fixed_t* const target_uv_base = SAFE_ALLOC(uv_w * 3, uv_h, fixed_t);\n fixed_t* const best_rgb_uv = SAFE_ALLOC(uv_w * 3, 1, fixed_t);\n fixed_y_t* best_y = best_y_base;\n fixed_y_t* target_y = target_y_base;\n fixed_t* best_uv = best_uv_base;\n fixed_t* target_uv = target_uv_base;\n const uint64_t diff_y_threshold = (uint64_t)(3.0 * w * h);\n int ok;\n assert(w > 0);\n assert(h > 0);\n\n if (best_y_base == NULL || best_uv_base == NULL ||\n target_y_base == NULL || target_uv_base == NULL ||\n best_rgb_y == NULL || best_rgb_uv == NULL ||\n tmp_buffer == NULL) {\n ok = 0;\n goto End;\n }\n\n // Import RGB samples to W/RGB representation.\n for (j = 0; j < height; j += 2) {\n const int is_last_row = (j == height - 1);\n fixed_y_t* const src1 = tmp_buffer + 0 * w;\n fixed_y_t* const src2 = tmp_buffer + 3 * w;\n\n // prepare two rows of input\n ImportOneRow(r_ptr, g_ptr, b_ptr, rgb_step, rgb_bit_depth, width,\n src1);\n if (!is_last_row) {\n ImportOneRow(r_ptr + rgb_stride, g_ptr + rgb_stride, b_ptr + rgb_stride,\n rgb_step, rgb_bit_depth, width, src2);\n } else {\n memcpy(src2, src1, 3 * w * sizeof(*src2));\n }\n StoreGray(src1, best_y + 0, w);\n StoreGray(src2, best_y + w, w);\n\n UpdateW(src1, target_y, w, rgb_bit_depth, transfer_type);\n UpdateW(src2, target_y + w, w, rgb_bit_depth, transfer_type);\n UpdateChroma(src1, src2, target_uv, uv_w, rgb_bit_depth, transfer_type);\n memcpy(best_uv, target_uv, 3 * uv_w * sizeof(*best_uv));\n best_y += 2 * w;\n best_uv += 3 * uv_w;\n target_y += 2 * w;\n target_uv += 3 * uv_w;\n r_ptr += 2 * rgb_stride;\n g_ptr += 2 * rgb_stride;\n b_ptr += 2 * rgb_stride;\n }\n\n // Iterate and resolve clipping conflicts.\n for (iter = 0; iter < kNumIterations; ++iter) {\n const fixed_t* cur_uv = best_uv_base;\n const fixed_t* prev_uv = best_uv_base;\n uint64_t diff_y_sum = 0;\n\n best_y = best_y_base;\n best_uv = best_uv_base;\n target_y = target_y_base;\n target_uv = target_uv_base;\n j = 0;\n do {\n fixed_y_t* const src1 = tmp_buffer + 0 * w;\n fixed_y_t* const src2 = tmp_buffer + 3 * w;\n {\n const fixed_t* const next_uv = cur_uv + ((j < h - 2) ? 3 * uv_w : 0);\n InterpolateTwoRows(best_y, prev_uv, cur_uv, next_uv, w,\n src1, src2, rgb_bit_depth);\n prev_uv = cur_uv;\n cur_uv = next_uv;\n }\n\n UpdateW(src1, best_rgb_y + 0 * w, w, rgb_bit_depth, transfer_type);\n UpdateW(src2, best_rgb_y + 1 * w, w, rgb_bit_depth, transfer_type);\n UpdateChroma(src1, src2, best_rgb_uv, uv_w, rgb_bit_depth, transfer_type);\n\n // update two rows of Y and one row of RGB\n diff_y_sum +=\n SharpYuvUpdateY(target_y, best_rgb_y, best_y, 2 * w, y_bit_depth);\n SharpYuvUpdateRGB(target_uv, best_rgb_uv, best_uv, 3 * uv_w);\n\n best_y += 2 * w;\n best_uv += 3 * uv_w;\n target_y += 2 * w;\n target_uv += 3 * uv_w;\n j += 2;\n } while (j < h);\n // test exit condition\n if (iter > 0) {\n if (diff_y_sum < diff_y_threshold) break;\n if (diff_y_sum > prev_diff_y_sum) break;\n }\n prev_diff_y_sum = diff_y_sum;\n }\n\n // final reconstruction\n ok = ConvertWRGBToYUV(best_y_base, best_uv_base, y_ptr, y_stride, u_ptr,\n u_stride, v_ptr, v_stride, rgb_bit_depth, yuv_bit_depth,\n width, height, yuv_matrix);\n\n End:\n free(best_y_base);\n free(best_uv_base);\n free(target_y_base);\n free(target_uv_base);\n free(best_rgb_y);\n free(best_rgb_uv);\n free(tmp_buffer);\n return ok;\n}\n\n#undef SAFE_ALLOC\n\n#if defined(WEBP_USE_THREAD) && !defined(_WIN32)\n#include <pthread.h> // NOLINT\n\n#define LOCK_ACCESS \\\n static pthread_mutex_t sharpyuv_lock = PTHREAD_MUTEX_INITIALIZER; \\\n if (pthread_mutex_lock(&sharpyuv_lock)) return\n#define UNLOCK_ACCESS_AND_RETURN \\\n do { \\\n (void)pthread_mutex_unlock(&sharpyuv_lock); \\\n return; \\\n } while (0)\n#else // !(defined(WEBP_USE_THREAD) && !defined(_WIN32))\n#define LOCK_ACCESS do {} while (0)\n#define UNLOCK_ACCESS_AND_RETURN return\n#endif // defined(WEBP_USE_THREAD) && !defined(_WIN32)\n\n// Hidden exported init function.\n// By default SharpYuvConvert calls it with SharpYuvGetCPUInfo. If needed,\n// users can declare it as extern and call it with an alternate VP8CPUInfo\n// function.\nextern VP8CPUInfo SharpYuvGetCPUInfo;\nSHARPYUV_EXTERN void SharpYuvInit(VP8CPUInfo cpu_info_func);\nvoid SharpYuvInit(VP8CPUInfo cpu_info_func) {\n static volatile VP8CPUInfo sharpyuv_last_cpuinfo_used =\n (VP8CPUInfo)&sharpyuv_last_cpuinfo_used;\n LOCK_ACCESS;\n // Only update SharpYuvGetCPUInfo when called from external code to avoid a\n // race on reading the value in SharpYuvConvert().\n if (cpu_info_func != (VP8CPUInfo)&SharpYuvGetCPUInfo) {\n SharpYuvGetCPUInfo = cpu_info_func;\n }\n if (sharpyuv_last_cpuinfo_used == SharpYuvGetCPUInfo) {\n UNLOCK_ACCESS_AND_RETURN;\n }\n\n SharpYuvInitDsp();\n SharpYuvInitGammaTables();\n\n sharpyuv_last_cpuinfo_used = SharpYuvGetCPUInfo;\n UNLOCK_ACCESS_AND_RETURN;\n}\n\nint SharpYuvConvert(const void* r_ptr, const void* g_ptr, const void* b_ptr,\n int rgb_step, int rgb_stride, int rgb_bit_depth,\n void* y_ptr, int y_stride, void* u_ptr, int u_stride,\n void* v_ptr, int v_stride, int yuv_bit_depth, int width,\n int height, const SharpYuvConversionMatrix* yuv_matrix) {\n SharpYuvOptions options;\n options.yuv_matrix = yuv_matrix;\n options.transfer_type = kSharpYuvTransferFunctionSrgb;\n return SharpYuvConvertWithOptions(\n r_ptr, g_ptr, b_ptr, rgb_step, rgb_stride, rgb_bit_depth, y_ptr, y_stride,\n u_ptr, u_stride, v_ptr, v_stride, yuv_bit_depth, width, height, &options);\n}\n\nint SharpYuvOptionsInitInternal(const SharpYuvConversionMatrix* yuv_matrix,\n SharpYuvOptions* options, int version) {\n const int major = (version >> 24);\n const int minor = (version >> 16) & 0xff;\n if (options == NULL || yuv_matrix == NULL ||\n (major == SHARPYUV_VERSION_MAJOR && major == 0 &&\n minor != SHARPYUV_VERSION_MINOR) ||\n (major != SHARPYUV_VERSION_MAJOR)) {\n return 0;\n }\n options->yuv_matrix = yuv_matrix;\n options->transfer_type = kSharpYuvTransferFunctionSrgb;\n return 1;\n}\n\nint SharpYuvConvertWithOptions(const void* r_ptr, const void* g_ptr,\n const void* b_ptr, int rgb_step, int rgb_stride,\n int rgb_bit_depth, void* y_ptr, int y_stride,\n void* u_ptr, int u_stride, void* v_ptr,\n int v_stride, int yuv_bit_depth, int width,\n int height, const SharpYuvOptions* options) {\n const SharpYuvConversionMatrix* yuv_matrix = options->yuv_matrix;\n SharpYuvTransferFunctionType transfer_type = options->transfer_type;\n SharpYuvConversionMatrix scaled_matrix;\n const int rgb_max = (1 << rgb_bit_depth) - 1;\n const int rgb_round = 1 << (rgb_bit_depth - 1);\n const int yuv_max = (1 << yuv_bit_depth) - 1;\n const int sfix = GetPrecisionShift(rgb_bit_depth);\n\n if (width < 1 || height < 1 || width == INT_MAX || height == INT_MAX ||\n r_ptr == NULL || g_ptr == NULL || b_ptr == NULL || y_ptr == NULL ||\n u_ptr == NULL || v_ptr == NULL) {\n return 0;\n }\n if (rgb_bit_depth != 8 && rgb_bit_depth != 10 && rgb_bit_depth != 12 &&\n rgb_bit_depth != 16) {\n return 0;\n }\n if (yuv_bit_depth != 8 && yuv_bit_depth != 10 && yuv_bit_depth != 12) {\n return 0;\n }\n if (rgb_bit_depth > 8 && (rgb_step % 2 != 0 || rgb_stride % 2 != 0)) {\n // Step/stride should be even for uint16_t buffers.\n return 0;\n }\n if (yuv_bit_depth > 8 &&\n (y_stride % 2 != 0 || u_stride % 2 != 0 || v_stride % 2 != 0)) {\n // Stride should be even for uint16_t buffers.\n return 0;\n }\n // The address of the function pointer is used to avoid a read race.\n SharpYuvInit((VP8CPUInfo)&SharpYuvGetCPUInfo);\n\n // Add scaling factor to go from rgb_bit_depth to yuv_bit_depth, to the\n // rgb->yuv conversion matrix.\n if (rgb_bit_depth == yuv_bit_depth) {\n memcpy(&scaled_matrix, yuv_matrix, sizeof(scaled_matrix));\n } else {\n int i;\n for (i = 0; i < 3; ++i) {\n scaled_matrix.rgb_to_y[i] =\n (yuv_matrix->rgb_to_y[i] * yuv_max + rgb_round) / rgb_max;\n scaled_matrix.rgb_to_u[i] =\n (yuv_matrix->rgb_to_u[i] * yuv_max + rgb_round) / rgb_max;\n scaled_matrix.rgb_to_v[i] =\n (yuv_matrix->rgb_to_v[i] * yuv_max + rgb_round) / rgb_max;\n }\n }\n // Also incorporate precision change scaling.\n scaled_matrix.rgb_to_y[3] = Shift(yuv_matrix->rgb_to_y[3], sfix);\n scaled_matrix.rgb_to_u[3] = Shift(yuv_matrix->rgb_to_u[3], sfix);\n scaled_matrix.rgb_to_v[3] = Shift(yuv_matrix->rgb_to_v[3], sfix);\n\n return DoSharpArgbToYuv(\n (const uint8_t*)r_ptr, (const uint8_t*)g_ptr, (const uint8_t*)b_ptr,\n rgb_step, rgb_stride, rgb_bit_depth, (uint8_t*)y_ptr, y_stride,\n (uint8_t*)u_ptr, u_stride, (uint8_t*)v_ptr, v_stride, yuv_bit_depth,\n width, height, &scaled_matrix, transfer_type);\n}\n\n//------------------------------------------------------------------------------\n"}}},{"rowIdx":22989,"cells":{"text":{"kind":"string","value":"// Copyright 2022 Google Inc. All Rights Reserved.\n//\n// Use of this source code is governed by a BSD-style license\n// that can be found in the COPYING file in the root of the source\n// tree. An additional intellectual property rights grant can be found\n// in the file PATENTS. All contributing project authors may\n// be found in the AUTHORS file in the root of the source tree.\n// -----------------------------------------------------------------------------\n//\n// Sharp RGB to YUV conversion.\n\n#ifndef WEBP_SHARPYUV_SHARPYUV_H_\n#define WEBP_SHARPYUV_SHARPYUV_H_\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#ifndef SHARPYUV_EXTERN\n#ifdef WEBP_EXTERN\n#define SHARPYUV_EXTERN WEBP_EXTERN\n#else\n// This explicitly marks library functions and allows for changing the\n// signature for e.g., Windows DLL builds.\n#if defined(_WIN32) && defined(WEBP_DLL)\n#define SHARPYUV_EXTERN __declspec(dllexport)\n#elif defined(__GNUC__) && __GNUC__ >= 4\n#define SHARPYUV_EXTERN extern __attribute__((visibility(\"default\")))\n#else\n#define SHARPYUV_EXTERN extern\n#endif /* defined(_WIN32) && defined(WEBP_DLL) */\n#endif /* WEBP_EXTERN */\n#endif /* SHARPYUV_EXTERN */\n\n#ifndef SHARPYUV_INLINE\n#ifdef WEBP_INLINE\n#define SHARPYUV_INLINE WEBP_INLINE\n#else\n#ifndef _MSC_VER\n#if defined(__cplusplus) || !defined(__STRICT_ANSI__) || \\\n (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)\n#define SHARPYUV_INLINE inline\n#else\n#define SHARPYUV_INLINE\n#endif\n#else\n#define SHARPYUV_INLINE __forceinline\n#endif /* _MSC_VER */\n#endif /* WEBP_INLINE */\n#endif /* SHARPYUV_INLINE */\n\n// SharpYUV API version following the convention from semver.org\n#define SHARPYUV_VERSION_MAJOR 0\n#define SHARPYUV_VERSION_MINOR 4\n#define SHARPYUV_VERSION_PATCH 2\n// Version as a uint32_t. The major number is the high 8 bits.\n// The minor number is the middle 8 bits. The patch number is the low 16 bits.\n#define SHARPYUV_MAKE_VERSION(MAJOR, MINOR, PATCH) \\\n (((MAJOR) << 24) | ((MINOR) << 16) | (PATCH))\n#define SHARPYUV_VERSION \\\n SHARPYUV_MAKE_VERSION(SHARPYUV_VERSION_MAJOR, SHARPYUV_VERSION_MINOR, \\\n SHARPYUV_VERSION_PATCH)\n\n// Returns the library's version number, packed in hexadecimal. See\n// SHARPYUV_VERSION.\nSHARPYUV_EXTERN int SharpYuvGetVersion(void);\n\n// RGB to YUV conversion matrix, in 16 bit fixed point.\n// y_ = rgb_to_y[0] * r + rgb_to_y[1] * g + rgb_to_y[2] * b + rgb_to_y[3]\n// u_ = rgb_to_u[0] * r + rgb_to_u[1] * g + rgb_to_u[2] * b + rgb_to_u[3]\n// v_ = rgb_to_v[0] * r + rgb_to_v[1] * g + rgb_to_v[2] * b + rgb_to_v[3]\n// Then the values are divided by 1<<16 and rounded.\n// y = (y_ + (1 << 15)) >> 16\n// u = (u_ + (1 << 15)) >> 16\n// v = (v_ + (1 << 15)) >> 16\n//\n// Typically, the offset values rgb_to_y[3], rgb_to_u[3] and rgb_to_v[3] depend\n// on the input's bit depth, e.g., rgb_to_u[3] = 1 << (rgb_bit_depth - 1 + 16).\n// See also sharpyuv_csp.h to get a predefined matrix or generate a matrix.\ntypedef struct {\n int rgb_to_y[4];\n int rgb_to_u[4];\n int rgb_to_v[4];\n} SharpYuvConversionMatrix;\n\ntypedef struct SharpYuvOptions SharpYuvOptions;\n\n// Enums for transfer functions, as defined in H.273,\n// https://www.itu.int/rec/T-REC-H.273-202107-I/en\ntypedef enum SharpYuvTransferFunctionType {\n // 0 is reserved\n kSharpYuvTransferFunctionBt709 = 1,\n // 2 is unspecified\n // 3 is reserved\n kSharpYuvTransferFunctionBt470M = 4,\n kSharpYuvTransferFunctionBt470Bg = 5,\n kSharpYuvTransferFunctionBt601 = 6,\n kSharpYuvTransferFunctionSmpte240 = 7,\n kSharpYuvTransferFunctionLinear = 8,\n kSharpYuvTransferFunctionLog100 = 9,\n kSharpYuvTransferFunctionLog100_Sqrt10 = 10,\n kSharpYuvTransferFunctionIec61966 = 11,\n kSharpYuvTransferFunctionBt1361 = 12,\n kSharpYuvTransferFunctionSrgb = 13,\n kSharpYuvTransferFunctionBt2020_10Bit = 14,\n kSharpYuvTransferFunctionBt2020_12Bit = 15,\n kSharpYuvTransferFunctionSmpte2084 = 16, // PQ\n kSharpYuvTransferFunctionSmpte428 = 17,\n kSharpYuvTransferFunctionHlg = 18,\n kSharpYuvTransferFunctionNum\n} SharpYuvTransferFunctionType;\n\n// Converts RGB to YUV420 using a downsampling algorithm that minimizes\n// artefacts caused by chroma subsampling.\n// This is slower than standard downsampling (averaging of 4 UV values).\n// Assumes that the image will be upsampled using a bilinear filter. If nearest\n// neighbor is used instead, the upsampled image might look worse than with\n// standard downsampling.\n// r_ptr, g_ptr, b_ptr: pointers to the source r, g and b channels. Should point\n// to uint8_t buffers if rgb_bit_depth is 8, or uint16_t buffers otherwise.\n// rgb_step: distance in bytes between two horizontally adjacent pixels on the\n// r, g and b channels. If rgb_bit_depth is > 8, it should be a\n// multiple of 2.\n// rgb_stride: distance in bytes between two vertically adjacent pixels on the\n// r, g, and b channels. If rgb_bit_depth is > 8, it should be a\n// multiple of 2.\n// rgb_bit_depth: number of bits for each r/g/b value. One of: 8, 10, 12, 16.\n// Note: 16 bit input is truncated to 14 bits before conversion to yuv.\n// yuv_bit_depth: number of bits for each y/u/v value. One of: 8, 10, 12.\n// y_ptr, u_ptr, v_ptr: pointers to the destination y, u and v channels. Should\n// point to uint8_t buffers if yuv_bit_depth is 8, or uint16_t buffers\n// otherwise.\n// y_stride, u_stride, v_stride: distance in bytes between two vertically\n// adjacent pixels on the y, u and v channels. If yuv_bit_depth > 8, they\n// should be multiples of 2.\n// width, height: width and height of the image in pixels\n// yuv_matrix: RGB to YUV conversion matrix. The matrix values typically\n// depend on the input's rgb_bit_depth.\n// This function calls SharpYuvConvertWithOptions with a default transfer\n// function of kSharpYuvTransferFunctionSrgb.\nSHARPYUV_EXTERN int SharpYuvConvert(const void* r_ptr, const void* g_ptr,\n const void* b_ptr, int rgb_step,\n int rgb_stride, int rgb_bit_depth,\n void* y_ptr, int y_stride, void* u_ptr,\n int u_stride, void* v_ptr, int v_stride,\n int yuv_bit_depth, int width, int height,\n const SharpYuvConversionMatrix* yuv_matrix);\n\nstruct SharpYuvOptions {\n // This matrix cannot be NULL and can be initialized by\n // SharpYuvComputeConversionMatrix.\n const SharpYuvConversionMatrix* yuv_matrix;\n SharpYuvTransferFunctionType transfer_type;\n};\n\n// Internal, version-checked, entry point\nSHARPYUV_EXTERN int SharpYuvOptionsInitInternal(const SharpYuvConversionMatrix*,\n SharpYuvOptions*, int);\n\n// Should always be called, to initialize a fresh SharpYuvOptions\n// structure before modification. SharpYuvOptionsInit() must have succeeded\n// before using the 'options' object.\nstatic SHARPYUV_INLINE int SharpYuvOptionsInit(\n const SharpYuvConversionMatrix* yuv_matrix, SharpYuvOptions* options) {\n return SharpYuvOptionsInitInternal(yuv_matrix, options, SHARPYUV_VERSION);\n}\n\nSHARPYUV_EXTERN int SharpYuvConvertWithOptions(\n const void* r_ptr, const void* g_ptr, const void* b_ptr, int rgb_step,\n int rgb_stride, int rgb_bit_depth, void* y_ptr, int y_stride, void* u_ptr,\n int u_stride, void* v_ptr, int v_stride, int yuv_bit_depth, int width,\n int height, const SharpYuvOptions* options);\n\n// TODO(b/194336375): Add YUV444 to YUV420 conversion. Maybe also add 422\n// support (it's rarely used in practice, especially for images).\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#endif // WEBP_SHARPYUV_SHARPYUV_H_\n"}}},{"rowIdx":22990,"cells":{"text":{"kind":"string","value":"// Copyright 2022 Google Inc. All Rights Reserved.\n//\n// Use of this source code is governed by a BSD-style license\n// that can be found in the COPYING file in the root of the source\n// tree. An additional intellectual property rights grant can be found\n// in the file PATENTS. All contributing project authors may\n// be found in the AUTHORS file in the root of the source tree.\n// -----------------------------------------------------------------------------\n//\n#include \"sharpyuv/sharpyuv_cpu.h\"\n\n// Include src/dsp/cpu.c to create SharpYuvGetCPUInfo from VP8GetCPUInfo. The\n// function pointer is renamed in sharpyuv_cpu.h.\n#include \"src/dsp/cpu.c\"\n"}}},{"rowIdx":22991,"cells":{"text":{"kind":"string","value":"// Copyright 2022 Google Inc. All Rights Reserved.\n//\n// Use of this source code is governed by a BSD-style license\n// that can be found in the COPYING file in the root of the source\n// tree. An additional intellectual property rights grant can be found\n// in the file PATENTS. All contributing project authors may\n// be found in the AUTHORS file in the root of the source tree.\n// -----------------------------------------------------------------------------\n//\n#ifndef WEBP_SHARPYUV_SHARPYUV_CPU_H_\n#define WEBP_SHARPYUV_SHARPYUV_CPU_H_\n\n#include \"sharpyuv/sharpyuv.h\"\n\n// Avoid exporting SharpYuvGetCPUInfo in shared object / DLL builds.\n// SharpYuvInit() replaces the use of the function pointer.\n#undef WEBP_EXTERN\n#define WEBP_EXTERN extern\n#define VP8GetCPUInfo SharpYuvGetCPUInfo\n#include \"src/dsp/cpu.h\"\n\n#endif // WEBP_SHARPYUV_SHARPYUV_CPU_H_\n"}}},{"rowIdx":22992,"cells":{"text":{"kind":"string","value":"// Copyright 2022 Google Inc. All Rights Reserved.\n//\n// Use of this source code is governed by a BSD-style license\n// that can be found in the COPYING file in the root of the source\n// tree. An additional intellectual property rights grant can be found\n// in the file PATENTS. All contributing project authors may\n// be found in the AUTHORS file in the root of the source tree.\n// -----------------------------------------------------------------------------\n//\n// Colorspace utilities.\n\n#include \"sharpyuv/sharpyuv_csp.h\"\n\n#include <assert.h>\n#include <math.h>\n#include <stddef.h>\n\n#include \"sharpyuv/sharpyuv.h\"\n\nstatic int ToFixed16(float f) { return (int)floor(f * (1 << 16) + 0.5f); }\n\nvoid SharpYuvComputeConversionMatrix(const SharpYuvColorSpace* yuv_color_space,\n SharpYuvConversionMatrix* matrix) {\n const float kr = yuv_color_space->kr;\n const float kb = yuv_color_space->kb;\n const float kg = 1.0f - kr - kb;\n const float cb = 0.5f / (1.0f - kb);\n const float cr = 0.5f / (1.0f - kr);\n\n const int shift = yuv_color_space->bit_depth - 8;\n\n const float denom = (float)((1 << yuv_color_space->bit_depth) - 1);\n float scale_y = 1.0f;\n float add_y = 0.0f;\n float scale_u = cb;\n float scale_v = cr;\n float add_uv = (float)(128 << shift);\n assert(yuv_color_space->bit_depth >= 8);\n\n if (yuv_color_space->range == kSharpYuvRangeLimited) {\n scale_y *= (219 << shift) / denom;\n scale_u *= (224 << shift) / denom;\n scale_v *= (224 << shift) / denom;\n add_y = (float)(16 << shift);\n }\n\n matrix->rgb_to_y[0] = ToFixed16(kr * scale_y);\n matrix->rgb_to_y[1] = ToFixed16(kg * scale_y);\n matrix->rgb_to_y[2] = ToFixed16(kb * scale_y);\n matrix->rgb_to_y[3] = ToFixed16(add_y);\n\n matrix->rgb_to_u[0] = ToFixed16(-kr * scale_u);\n matrix->rgb_to_u[1] = ToFixed16(-kg * scale_u);\n matrix->rgb_to_u[2] = ToFixed16((1 - kb) * scale_u);\n matrix->rgb_to_u[3] = ToFixed16(add_uv);\n\n matrix->rgb_to_v[0] = ToFixed16((1 - kr) * scale_v);\n matrix->rgb_to_v[1] = ToFixed16(-kg * scale_v);\n matrix->rgb_to_v[2] = ToFixed16(-kb * scale_v);\n matrix->rgb_to_v[3] = ToFixed16(add_uv);\n}\n\n// Matrices are in YUV_FIX fixed point precision.\n// WebP's matrix, similar but not identical to kRec601LimitedMatrix\n// Derived using the following formulas:\n// Y = 0.2569 * R + 0.5044 * G + 0.0979 * B + 16\n// U = -0.1483 * R - 0.2911 * G + 0.4394 * B + 128\n// V = 0.4394 * R - 0.3679 * G - 0.0715 * B + 128\nstatic const SharpYuvConversionMatrix kWebpMatrix = {\n {16839, 33059, 6420, 16 << 16},\n {-9719, -19081, 28800, 128 << 16},\n {28800, -24116, -4684, 128 << 16},\n};\n// Kr=0.2990f Kb=0.1140f bit_depth=8 range=kSharpYuvRangeLimited\nstatic const SharpYuvConversionMatrix kRec601LimitedMatrix = {\n {16829, 33039, 6416, 16 << 16},\n {-9714, -19071, 28784, 128 << 16},\n {28784, -24103, -4681, 128 << 16},\n};\n// Kr=0.2990f Kb=0.1140f bit_depth=8 range=kSharpYuvRangeFull\nstatic const SharpYuvConversionMatrix kRec601FullMatrix = {\n {19595, 38470, 7471, 0},\n {-11058, -21710, 32768, 128 << 16},\n {32768, -27439, -5329, 128 << 16},\n};\n// Kr=0.2126f Kb=0.0722f bit_depth=8 range=kSharpYuvRangeLimited\nstatic const SharpYuvConversionMatrix kRec709LimitedMatrix = {\n {11966, 40254, 4064, 16 << 16},\n {-6596, -22189, 28784, 128 << 16},\n {28784, -26145, -2639, 128 << 16},\n};\n// Kr=0.2126f Kb=0.0722f bit_depth=8 range=kSharpYuvRangeFull\nstatic const SharpYuvConversionMatrix kRec709FullMatrix = {\n {13933, 46871, 4732, 0},\n {-7509, -25259, 32768, 128 << 16},\n {32768, -29763, -3005, 128 << 16},\n};\n\nconst SharpYuvConversionMatrix* SharpYuvGetConversionMatrix(\n SharpYuvMatrixType matrix_type) {\n switch (matrix_type) {\n case kSharpYuvMatrixWebp:\n return &kWebpMatrix;\n case kSharpYuvMatrixRec601Limited:\n return &kRec601LimitedMatrix;\n case kSharpYuvMatrixRec601Full:\n return &kRec601FullMatrix;\n case kSharpYuvMatrixRec709Limited:\n return &kRec709LimitedMatrix;\n case kSharpYuvMatrixRec709Full:\n return &kRec709FullMatrix;\n case kSharpYuvMatrixNum:\n return NULL;\n }\n return NULL;\n}\n"}}},{"rowIdx":22993,"cells":{"text":{"kind":"string","value":"// Copyright 2022 Google Inc. All Rights Reserved.\n//\n// Use of this source code is governed by a BSD-style license\n// that can be found in the COPYING file in the root of the source\n// tree. An additional intellectual property rights grant can be found\n// in the file PATENTS. All contributing project authors may\n// be found in the AUTHORS file in the root of the source tree.\n// -----------------------------------------------------------------------------\n//\n// Colorspace utilities.\n\n#ifndef WEBP_SHARPYUV_SHARPYUV_CSP_H_\n#define WEBP_SHARPYUV_SHARPYUV_CSP_H_\n\n#include \"sharpyuv/sharpyuv.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// Range of YUV values.\ntypedef enum {\n kSharpYuvRangeFull, // YUV values between [0;255] (for 8 bit)\n kSharpYuvRangeLimited // Y in [16;235], YUV in [16;240] (for 8 bit)\n} SharpYuvRange;\n\n// Constants that define a YUV color space.\ntypedef struct {\n // Kr and Kb are defined such that:\n // Y = Kr * r + Kg * g + Kb * b where Kg = 1 - Kr - Kb.\n float kr;\n float kb;\n int bit_depth; // 8, 10 or 12\n SharpYuvRange range;\n} SharpYuvColorSpace;\n\n// Fills in 'matrix' for the given YUVColorSpace.\nSHARPYUV_EXTERN void SharpYuvComputeConversionMatrix(\n const SharpYuvColorSpace* yuv_color_space,\n SharpYuvConversionMatrix* matrix);\n\n// Enums for precomputed conversion matrices.\ntypedef enum {\n // WebP's matrix, similar but not identical to kSharpYuvMatrixRec601Limited\n kSharpYuvMatrixWebp = 0,\n // Kr=0.2990f Kb=0.1140f bit_depth=8 range=kSharpYuvRangeLimited\n kSharpYuvMatrixRec601Limited,\n // Kr=0.2990f Kb=0.1140f bit_depth=8 range=kSharpYuvRangeFull\n kSharpYuvMatrixRec601Full,\n // Kr=0.2126f Kb=0.0722f bit_depth=8 range=kSharpYuvRangeLimited\n kSharpYuvMatrixRec709Limited,\n // Kr=0.2126f Kb=0.0722f bit_depth=8 range=kSharpYuvRangeFull\n kSharpYuvMatrixRec709Full,\n kSharpYuvMatrixNum\n} SharpYuvMatrixType;\n\n// Returns a pointer to a matrix for one of the predefined colorspaces.\nSHARPYUV_EXTERN const SharpYuvConversionMatrix* SharpYuvGetConversionMatrix(\n SharpYuvMatrixType matrix_type);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#endif // WEBP_SHARPYUV_SHARPYUV_CSP_H_\n"}}},{"rowIdx":22994,"cells":{"text":{"kind":"string","value":"// Copyright 2022 Google Inc. All Rights Reserved.\n//\n// Use of this source code is governed by a BSD-style license\n// that can be found in the COPYING file in the root of the source\n// tree. An additional intellectual property rights grant can be found\n// in the file PATENTS. All contributing project authors may\n// be found in the AUTHORS file in the root of the source tree.\n// -----------------------------------------------------------------------------\n//\n// Speed-critical functions for Sharp YUV.\n//\n// Author: Skal (pascal.massimino@gmail.com)\n\n#include \"sharpyuv/sharpyuv_dsp.h\"\n\n#include <assert.h>\n#include <stdlib.h>\n\n#include \"sharpyuv/sharpyuv_cpu.h\"\n#include \"src/dsp/cpu.h\"\n#include \"src/webp/types.h\"\n\n//-----------------------------------------------------------------------------\n\n#if !WEBP_NEON_OMIT_C_CODE\nstatic uint16_t clip(int v, int max) {\n return (v < 0) ? 0 : (v > max) ? max : (uint16_t)v;\n}\n\nstatic uint64_t SharpYuvUpdateY_C(const uint16_t* ref, const uint16_t* src,\n uint16_t* dst, int len, int bit_depth) {\n uint64_t diff = 0;\n int i;\n const int max_y = (1 << bit_depth) - 1;\n for (i = 0; i < len; ++i) {\n const int diff_y = ref[i] - src[i];\n const int new_y = (int)dst[i] + diff_y;\n dst[i] = clip(new_y, max_y);\n diff += (uint64_t)abs(diff_y);\n }\n return diff;\n}\n\nstatic void SharpYuvUpdateRGB_C(const int16_t* ref, const int16_t* src,\n int16_t* dst, int len) {\n int i;\n for (i = 0; i < len; ++i) {\n const int diff_uv = ref[i] - src[i];\n dst[i] += diff_uv;\n }\n}\n\nstatic void SharpYuvFilterRow_C(const int16_t* A, const int16_t* B, int len,\n const uint16_t* best_y, uint16_t* out,\n int bit_depth) {\n int i;\n const int max_y = (1 << bit_depth) - 1;\n for (i = 0; i < len; ++i, ++A, ++B) {\n const int v0 = (A[0] * 9 + A[1] * 3 + B[0] * 3 + B[1] + 8) >> 4;\n const int v1 = (A[1] * 9 + A[0] * 3 + B[1] * 3 + B[0] + 8) >> 4;\n out[2 * i + 0] = clip(best_y[2 * i + 0] + v0, max_y);\n out[2 * i + 1] = clip(best_y[2 * i + 1] + v1, max_y);\n }\n}\n#endif // !WEBP_NEON_OMIT_C_CODE\n\n//-----------------------------------------------------------------------------\n\nuint64_t (*SharpYuvUpdateY)(const uint16_t* src, const uint16_t* ref,\n uint16_t* dst, int len, int bit_depth);\nvoid (*SharpYuvUpdateRGB)(const int16_t* src, const int16_t* ref, int16_t* dst,\n int len);\nvoid (*SharpYuvFilterRow)(const int16_t* A, const int16_t* B, int len,\n const uint16_t* best_y, uint16_t* out, int bit_depth);\n\nextern VP8CPUInfo SharpYuvGetCPUInfo;\nextern void InitSharpYuvSSE2(void);\nextern void InitSharpYuvNEON(void);\n\nvoid SharpYuvInitDsp(void) {\n#if !WEBP_NEON_OMIT_C_CODE\n SharpYuvUpdateY = SharpYuvUpdateY_C;\n SharpYuvUpdateRGB = SharpYuvUpdateRGB_C;\n SharpYuvFilterRow = SharpYuvFilterRow_C;\n#endif\n\n if (SharpYuvGetCPUInfo != NULL) {\n#if defined(WEBP_HAVE_SSE2)\n if (SharpYuvGetCPUInfo(kSSE2)) {\n InitSharpYuvSSE2();\n }\n#endif // WEBP_HAVE_SSE2\n }\n\n#if defined(WEBP_HAVE_NEON)\n if (WEBP_NEON_OMIT_C_CODE ||\n (SharpYuvGetCPUInfo != NULL && SharpYuvGetCPUInfo(kNEON))) {\n InitSharpYuvNEON();\n }\n#endif // WEBP_HAVE_NEON\n\n assert(SharpYuvUpdateY != NULL);\n assert(SharpYuvUpdateRGB != NULL);\n assert(SharpYuvFilterRow != NULL);\n}\n"}}},{"rowIdx":22995,"cells":{"text":{"kind":"string","value":"// Copyright 2022 Google Inc. All Rights Reserved.\n//\n// Use of this source code is governed by a BSD-style license\n// that can be found in the COPYING file in the root of the source\n// tree. An additional intellectual property rights grant can be found\n// in the file PATENTS. All contributing project authors may\n// be found in the AUTHORS file in the root of the source tree.\n// -----------------------------------------------------------------------------\n//\n// Speed-critical functions for Sharp YUV.\n\n#ifndef WEBP_SHARPYUV_SHARPYUV_DSP_H_\n#define WEBP_SHARPYUV_SHARPYUV_DSP_H_\n\n#include \"sharpyuv/sharpyuv_cpu.h\"\n#include \"src/webp/types.h\"\n\nextern uint64_t (*SharpYuvUpdateY)(const uint16_t* src, const uint16_t* ref,\n uint16_t* dst, int len, int bit_depth);\nextern void (*SharpYuvUpdateRGB)(const int16_t* src, const int16_t* ref,\n int16_t* dst, int len);\nextern void (*SharpYuvFilterRow)(const int16_t* A, const int16_t* B, int len,\n const uint16_t* best_y, uint16_t* out,\n int bit_depth);\n\nvoid SharpYuvInitDsp(void);\n\n#endif // WEBP_SHARPYUV_SHARPYUV_DSP_H_\n"}}},{"rowIdx":22996,"cells":{"text":{"kind":"string","value":"// Copyright 2022 Google Inc. All Rights Reserved.\n//\n// Use of this source code is governed by a BSD-style license\n// that can be found in the COPYING file in the root of the source\n// tree. An additional intellectual property rights grant can be found\n// in the file PATENTS. All contributing project authors may\n// be found in the AUTHORS file in the root of the source tree.\n// -----------------------------------------------------------------------------\n//\n// Gamma correction utilities.\n\n#include \"sharpyuv/sharpyuv_gamma.h\"\n\n#include <assert.h>\n#include <float.h>\n#include <math.h>\n\n#include \"sharpyuv/sharpyuv.h\"\n#include \"src/webp/types.h\"\n\n// Gamma correction compensates loss of resolution during chroma subsampling.\n// Size of pre-computed table for converting from gamma to linear.\n#define GAMMA_TO_LINEAR_TAB_BITS 10\n#define GAMMA_TO_LINEAR_TAB_SIZE (1 << GAMMA_TO_LINEAR_TAB_BITS)\nstatic uint32_t kGammaToLinearTabS[GAMMA_TO_LINEAR_TAB_SIZE + 2];\n#define LINEAR_TO_GAMMA_TAB_BITS 9\n#define LINEAR_TO_GAMMA_TAB_SIZE (1 << LINEAR_TO_GAMMA_TAB_BITS)\nstatic uint32_t kLinearToGammaTabS[LINEAR_TO_GAMMA_TAB_SIZE + 2];\n\nstatic const double kGammaF = 1. / 0.45;\n#define GAMMA_TO_LINEAR_BITS 16\n\nstatic volatile int kGammaTablesSOk = 0;\nvoid SharpYuvInitGammaTables(void) {\n assert(GAMMA_TO_LINEAR_BITS <= 16);\n if (!kGammaTablesSOk) {\n int v;\n const double a = 0.09929682680944;\n const double thresh = 0.018053968510807;\n const double final_scale = 1 << GAMMA_TO_LINEAR_BITS;\n // Precompute gamma to linear table.\n {\n const double norm = 1. / GAMMA_TO_LINEAR_TAB_SIZE;\n const double a_rec = 1. / (1. + a);\n for (v = 0; v <= GAMMA_TO_LINEAR_TAB_SIZE; ++v) {\n const double g = norm * v;\n double value;\n if (g <= thresh * 4.5) {\n value = g / 4.5;\n } else {\n value = pow(a_rec * (g + a), kGammaF);\n }\n kGammaToLinearTabS[v] = (uint32_t)(value * final_scale + .5);\n }\n // to prevent small rounding errors to cause read-overflow:\n kGammaToLinearTabS[GAMMA_TO_LINEAR_TAB_SIZE + 1] =\n kGammaToLinearTabS[GAMMA_TO_LINEAR_TAB_SIZE];\n }\n // Precompute linear to gamma table.\n {\n const double scale = 1. / LINEAR_TO_GAMMA_TAB_SIZE;\n for (v = 0; v <= LINEAR_TO_GAMMA_TAB_SIZE; ++v) {\n const double g = scale * v;\n double value;\n if (g <= thresh) {\n value = 4.5 * g;\n } else {\n value = (1. + a) * pow(g, 1. / kGammaF) - a;\n }\n kLinearToGammaTabS[v] =\n (uint32_t)(final_scale * value + 0.5);\n }\n // to prevent small rounding errors to cause read-overflow:\n kLinearToGammaTabS[LINEAR_TO_GAMMA_TAB_SIZE + 1] =\n kLinearToGammaTabS[LINEAR_TO_GAMMA_TAB_SIZE];\n }\n kGammaTablesSOk = 1;\n }\n}\n\nstatic WEBP_INLINE int Shift(int v, int shift) {\n return (shift >= 0) ? (v << shift) : (v >> -shift);\n}\n\nstatic WEBP_INLINE uint32_t FixedPointInterpolation(int v, uint32_t* tab,\n int tab_pos_shift_right,\n int tab_value_shift) {\n const uint32_t tab_pos = Shift(v, -tab_pos_shift_right);\n // fractional part, in 'tab_pos_shift' fixed-point precision\n const uint32_t x = v - (tab_pos << tab_pos_shift_right); // fractional part\n // v0 / v1 are in kGammaToLinearBits fixed-point precision (range [0..1])\n const uint32_t v0 = Shift(tab[tab_pos + 0], tab_value_shift);\n const uint32_t v1 = Shift(tab[tab_pos + 1], tab_value_shift);\n // Final interpolation.\n const uint32_t v2 = (v1 - v0) * x; // note: v1 >= v0.\n const int half =\n (tab_pos_shift_right > 0) ? 1 << (tab_pos_shift_right - 1) : 0;\n const uint32_t result = v0 + ((v2 + half) >> tab_pos_shift_right);\n return result;\n}\n\nstatic uint32_t ToLinearSrgb(uint16_t v, int bit_depth) {\n const int shift = GAMMA_TO_LINEAR_TAB_BITS - bit_depth;\n if (shift > 0) {\n return kGammaToLinearTabS[v << shift];\n }\n return FixedPointInterpolation(v, kGammaToLinearTabS, -shift, 0);\n}\n\nstatic uint16_t FromLinearSrgb(uint32_t value, int bit_depth) {\n return FixedPointInterpolation(\n value, kLinearToGammaTabS,\n (GAMMA_TO_LINEAR_BITS - LINEAR_TO_GAMMA_TAB_BITS),\n bit_depth - GAMMA_TO_LINEAR_BITS);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\n#define CLAMP(x, low, high) \\\n (((x) < (low)) ? (low) : (((high) < (x)) ? (high) : (x)))\n#define MIN(a, b) (((a) < (b)) ? (a) : (b))\n#define MAX(a, b) (((a) > (b)) ? (a) : (b))\n\nstatic WEBP_INLINE float Roundf(float x) {\n if (x < 0)\n return (float)ceil((double)(x - 0.5f));\n else\n return (float)floor((double)(x + 0.5f));\n}\n\nstatic WEBP_INLINE float Powf(float base, float exp) {\n return (float)pow((double)base, (double)exp);\n}\n\nstatic WEBP_INLINE float Log10f(float x) { return (float)log10((double)x); }\n\nstatic float ToLinear709(float gamma) {\n if (gamma < 0.f) {\n return 0.f;\n } else if (gamma < 4.5f * 0.018053968510807f) {\n return gamma / 4.5f;\n } else if (gamma < 1.f) {\n return Powf((gamma + 0.09929682680944f) / 1.09929682680944f, 1.f / 0.45f);\n }\n return 1.f;\n}\n\nstatic float FromLinear709(float linear) {\n if (linear < 0.f) {\n return 0.f;\n } else if (linear < 0.018053968510807f) {\n return linear * 4.5f;\n } else if (linear < 1.f) {\n return 1.09929682680944f * Powf(linear, 0.45f) - 0.09929682680944f;\n }\n return 1.f;\n}\n\nstatic float ToLinear470M(float gamma) {\n return Powf(CLAMP(gamma, 0.f, 1.f), 2.2f);\n}\n\nstatic float FromLinear470M(float linear) {\n return Powf(CLAMP(linear, 0.f, 1.f), 1.f / 2.2f);\n}\n\nstatic float ToLinear470Bg(float gamma) {\n return Powf(CLAMP(gamma, 0.f, 1.f), 2.8f);\n}\n\nstatic float FromLinear470Bg(float linear) {\n return Powf(CLAMP(linear, 0.f, 1.f), 1.f / 2.8f);\n}\n\nstatic float ToLinearSmpte240(float gamma) {\n if (gamma < 0.f) {\n return 0.f;\n } else if (gamma < 4.f * 0.022821585529445f) {\n return gamma / 4.f;\n } else if (gamma < 1.f) {\n return Powf((gamma + 0.111572195921731f) / 1.111572195921731f, 1.f / 0.45f);\n }\n return 1.f;\n}\n\nstatic float FromLinearSmpte240(float linear) {\n if (linear < 0.f) {\n return 0.f;\n } else if (linear < 0.022821585529445f) {\n return linear * 4.f;\n } else if (linear < 1.f) {\n return 1.111572195921731f * Powf(linear, 0.45f) - 0.111572195921731f;\n }\n return 1.f;\n}\n\nstatic float ToLinearLog100(float gamma) {\n // The function is non-bijective so choose the middle of [0, 0.01].\n const float mid_interval = 0.01f / 2.f;\n return (gamma <= 0.0f) ? mid_interval\n : Powf(10.0f, 2.f * (MIN(gamma, 1.f) - 1.0f));\n}\n\nstatic float FromLinearLog100(float linear) {\n return (linear < 0.01f) ? 0.0f : 1.0f + Log10f(MIN(linear, 1.f)) / 2.0f;\n}\n\nstatic float ToLinearLog100Sqrt10(float gamma) {\n // The function is non-bijective so choose the middle of [0, 0.00316227766f[.\n const float mid_interval = 0.00316227766f / 2.f;\n return (gamma <= 0.0f) ? mid_interval\n : Powf(10.0f, 2.5f * (MIN(gamma, 1.f) - 1.0f));\n}\n\nstatic float FromLinearLog100Sqrt10(float linear) {\n return (linear < 0.00316227766f) ? 0.0f\n : 1.0f + Log10f(MIN(linear, 1.f)) / 2.5f;\n}\n\nstatic float ToLinearIec61966(float gamma) {\n if (gamma <= -4.5f * 0.018053968510807f) {\n return Powf((-gamma + 0.09929682680944f) / -1.09929682680944f, 1.f / 0.45f);\n } else if (gamma < 4.5f * 0.018053968510807f) {\n return gamma / 4.5f;\n }\n return Powf((gamma + 0.09929682680944f) / 1.09929682680944f, 1.f / 0.45f);\n}\n\nstatic float FromLinearIec61966(float linear) {\n if (linear <= -0.018053968510807f) {\n return -1.09929682680944f * Powf(-linear, 0.45f) + 0.09929682680944f;\n } else if (linear < 0.018053968510807f) {\n return linear * 4.5f;\n }\n return 1.09929682680944f * Powf(linear, 0.45f) - 0.09929682680944f;\n}\n\nstatic float ToLinearBt1361(float gamma) {\n if (gamma < -0.25f) {\n return -0.25f;\n } else if (gamma < 0.f) {\n return Powf((gamma - 0.02482420670236f) / -0.27482420670236f, 1.f / 0.45f) /\n -4.f;\n } else if (gamma < 4.5f * 0.018053968510807f) {\n return gamma / 4.5f;\n } else if (gamma < 1.f) {\n return Powf((gamma + 0.09929682680944f) / 1.09929682680944f, 1.f / 0.45f);\n }\n return 1.f;\n}\n\nstatic float FromLinearBt1361(float linear) {\n if (linear < -0.25f) {\n return -0.25f;\n } else if (linear < 0.f) {\n return -0.27482420670236f * Powf(-4.f * linear, 0.45f) + 0.02482420670236f;\n } else if (linear < 0.018053968510807f) {\n return linear * 4.5f;\n } else if (linear < 1.f) {\n return 1.09929682680944f * Powf(linear, 0.45f) - 0.09929682680944f;\n }\n return 1.f;\n}\n\nstatic float ToLinearPq(float gamma) {\n if (gamma > 0.f) {\n const float pow_gamma = Powf(gamma, 32.f / 2523.f);\n const float num = MAX(pow_gamma - 107.f / 128.f, 0.0f);\n const float den = MAX(2413.f / 128.f - 2392.f / 128.f * pow_gamma, FLT_MIN);\n return Powf(num / den, 4096.f / 653.f);\n }\n return 0.f;\n}\n\nstatic float FromLinearPq(float linear) {\n if (linear > 0.f) {\n const float pow_linear = Powf(linear, 653.f / 4096.f);\n const float num = 107.f / 128.f + 2413.f / 128.f * pow_linear;\n const float den = 1.0f + 2392.f / 128.f * pow_linear;\n return Powf(num / den, 2523.f / 32.f);\n }\n return 0.f;\n}\n\nstatic float ToLinearSmpte428(float gamma) {\n return Powf(MAX(gamma, 0.f), 2.6f) / 0.91655527974030934f;\n}\n\nstatic float FromLinearSmpte428(float linear) {\n return Powf(0.91655527974030934f * MAX(linear, 0.f), 1.f / 2.6f);\n}\n\n// Conversion in BT.2100 requires RGB info. Simplify to gamma correction here.\nstatic float ToLinearHlg(float gamma) {\n if (gamma < 0.f) {\n return 0.f;\n } else if (gamma <= 0.5f) {\n return Powf((gamma * gamma) * (1.f / 3.f), 1.2f);\n }\n return Powf((expf((gamma - 0.55991073f) / 0.17883277f) + 0.28466892f) / 12.0f,\n 1.2f);\n}\n\nstatic float FromLinearHlg(float linear) {\n linear = Powf(linear, 1.f / 1.2f);\n if (linear < 0.f) {\n return 0.f;\n } else if (linear <= (1.f / 12.f)) {\n return sqrtf(3.f * linear);\n }\n return 0.17883277f * logf(12.f * linear - 0.28466892f) + 0.55991073f;\n}\n\nuint32_t SharpYuvGammaToLinear(uint16_t v, int bit_depth,\n SharpYuvTransferFunctionType transfer_type) {\n float v_float, linear;\n if (transfer_type == kSharpYuvTransferFunctionSrgb) {\n return ToLinearSrgb(v, bit_depth);\n }\n v_float = (float)v / ((1 << bit_depth) - 1);\n switch (transfer_type) {\n case kSharpYuvTransferFunctionBt709:\n case kSharpYuvTransferFunctionBt601:\n case kSharpYuvTransferFunctionBt2020_10Bit:\n case kSharpYuvTransferFunctionBt2020_12Bit:\n linear = ToLinear709(v_float);\n break;\n case kSharpYuvTransferFunctionBt470M:\n linear = ToLinear470M(v_float);\n break;\n case kSharpYuvTransferFunctionBt470Bg:\n linear = ToLinear470Bg(v_float);\n break;\n case kSharpYuvTransferFunctionSmpte240:\n linear = ToLinearSmpte240(v_float);\n break;\n case kSharpYuvTransferFunctionLinear:\n return v;\n case kSharpYuvTransferFunctionLog100:\n linear = ToLinearLog100(v_float);\n break;\n case kSharpYuvTransferFunctionLog100_Sqrt10:\n linear = ToLinearLog100Sqrt10(v_float);\n break;\n case kSharpYuvTransferFunctionIec61966:\n linear = ToLinearIec61966(v_float);\n break;\n case kSharpYuvTransferFunctionBt1361:\n linear = ToLinearBt1361(v_float);\n break;\n case kSharpYuvTransferFunctionSmpte2084:\n linear = ToLinearPq(v_float);\n break;\n case kSharpYuvTransferFunctionSmpte428:\n linear = ToLinearSmpte428(v_float);\n break;\n case kSharpYuvTransferFunctionHlg:\n linear = ToLinearHlg(v_float);\n break;\n default:\n assert(0);\n linear = 0;\n break;\n }\n return (uint32_t)Roundf(linear * ((1 << 16) - 1));\n}\n\nuint16_t SharpYuvLinearToGamma(uint32_t v, int bit_depth,\n SharpYuvTransferFunctionType transfer_type) {\n float v_float, linear;\n if (transfer_type == kSharpYuvTransferFunctionSrgb) {\n return FromLinearSrgb(v, bit_depth);\n }\n v_float = (float)v / ((1 << 16) - 1);\n switch (transfer_type) {\n case kSharpYuvTransferFunctionBt709:\n case kSharpYuvTransferFunctionBt601:\n case kSharpYuvTransferFunctionBt2020_10Bit:\n case kSharpYuvTransferFunctionBt2020_12Bit:\n linear = FromLinear709(v_float);\n break;\n case kSharpYuvTransferFunctionBt470M:\n linear = FromLinear470M(v_float);\n break;\n case kSharpYuvTransferFunctionBt470Bg:\n linear = FromLinear470Bg(v_float);\n break;\n case kSharpYuvTransferFunctionSmpte240:\n linear = FromLinearSmpte240(v_float);\n break;\n case kSharpYuvTransferFunctionLinear:\n return v;\n case kSharpYuvTransferFunctionLog100:\n linear = FromLinearLog100(v_float);\n break;\n case kSharpYuvTransferFunctionLog100_Sqrt10:\n linear = FromLinearLog100Sqrt10(v_float);\n break;\n case kSharpYuvTransferFunctionIec61966:\n linear = FromLinearIec61966(v_float);\n break;\n case kSharpYuvTransferFunctionBt1361:\n linear = FromLinearBt1361(v_float);\n break;\n case kSharpYuvTransferFunctionSmpte2084:\n linear = FromLinearPq(v_float);\n break;\n case kSharpYuvTransferFunctionSmpte428:\n linear = FromLinearSmpte428(v_float);\n break;\n case kSharpYuvTransferFunctionHlg:\n linear = FromLinearHlg(v_float);\n break;\n default:\n assert(0);\n linear = 0;\n break;\n }\n return (uint16_t)Roundf(linear * ((1 << bit_depth) - 1));\n}\n"}}},{"rowIdx":22997,"cells":{"text":{"kind":"string","value":"// Copyright 2022 Google Inc. All Rights Reserved.\n//\n// Use of this source code is governed by a BSD-style license\n// that can be found in the COPYING file in the root of the source\n// tree. An additional intellectual property rights grant can be found\n// in the file PATENTS. All contributing project authors may\n// be found in the AUTHORS file in the root of the source tree.\n// -----------------------------------------------------------------------------\n//\n// Gamma correction utilities.\n\n#ifndef WEBP_SHARPYUV_SHARPYUV_GAMMA_H_\n#define WEBP_SHARPYUV_SHARPYUV_GAMMA_H_\n\n#include \"sharpyuv/sharpyuv.h\"\n#include \"src/webp/types.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// Initializes precomputed tables. Must be called once before calling\n// SharpYuvGammaToLinear or SharpYuvLinearToGamma.\nvoid SharpYuvInitGammaTables(void);\n\n// Converts a 'bit_depth'-bit gamma color value to a 16-bit linear value.\nuint32_t SharpYuvGammaToLinear(uint16_t v, int bit_depth,\n SharpYuvTransferFunctionType transfer_type);\n\n// Converts a 16-bit linear color value to a 'bit_depth'-bit gamma value.\nuint16_t SharpYuvLinearToGamma(uint32_t value, int bit_depth,\n SharpYuvTransferFunctionType transfer_type);\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#endif // WEBP_SHARPYUV_SHARPYUV_GAMMA_H_\n"}}},{"rowIdx":22998,"cells":{"text":{"kind":"string","value":"// Copyright 2022 Google Inc. All Rights Reserved.\n//\n// Use of this source code is governed by a BSD-style license\n// that can be found in the COPYING file in the root of the source\n// tree. An additional intellectual property rights grant can be found\n// in the file PATENTS. All contributing project authors may\n// be found in the AUTHORS file in the root of the source tree.\n// -----------------------------------------------------------------------------\n//\n// Speed-critical functions for Sharp YUV.\n//\n// Author: Skal (pascal.massimino@gmail.com)\n\n#include \"sharpyuv/sharpyuv_dsp.h\"\n\n#if defined(WEBP_USE_NEON)\n#include <assert.h>\n#include <stdlib.h>\n#include <arm_neon.h>\n\nstatic uint16_t clip_NEON(int v, int max) {\n return (v < 0) ? 0 : (v > max) ? max : (uint16_t)v;\n}\n\nstatic uint64_t SharpYuvUpdateY_NEON(const uint16_t* ref, const uint16_t* src,\n uint16_t* dst, int len, int bit_depth) {\n const int max_y = (1 << bit_depth) - 1;\n int i;\n const int16x8_t zero = vdupq_n_s16(0);\n const int16x8_t max = vdupq_n_s16(max_y);\n uint64x2_t sum = vdupq_n_u64(0);\n uint64_t diff;\n\n for (i = 0; i + 8 <= len; i += 8) {\n const int16x8_t A = vreinterpretq_s16_u16(vld1q_u16(ref + i));\n const int16x8_t B = vreinterpretq_s16_u16(vld1q_u16(src + i));\n const int16x8_t C = vreinterpretq_s16_u16(vld1q_u16(dst + i));\n const int16x8_t D = vsubq_s16(A, B); // diff_y\n const int16x8_t F = vaddq_s16(C, D); // new_y\n const uint16x8_t H =\n vreinterpretq_u16_s16(vmaxq_s16(vminq_s16(F, max), zero));\n const int16x8_t I = vabsq_s16(D); // abs(diff_y)\n vst1q_u16(dst + i, H);\n sum = vpadalq_u32(sum, vpaddlq_u16(vreinterpretq_u16_s16(I)));\n }\n diff = vgetq_lane_u64(sum, 0) + vgetq_lane_u64(sum, 1);\n for (; i < len; ++i) {\n const int diff_y = ref[i] - src[i];\n const int new_y = (int)(dst[i]) + diff_y;\n dst[i] = clip_NEON(new_y, max_y);\n diff += (uint64_t)(abs(diff_y));\n }\n return diff;\n}\n\nstatic void SharpYuvUpdateRGB_NEON(const int16_t* ref, const int16_t* src,\n int16_t* dst, int len) {\n int i;\n for (i = 0; i + 8 <= len; i += 8) {\n const int16x8_t A = vld1q_s16(ref + i);\n const int16x8_t B = vld1q_s16(src + i);\n const int16x8_t C = vld1q_s16(dst + i);\n const int16x8_t D = vsubq_s16(A, B); // diff_uv\n const int16x8_t E = vaddq_s16(C, D); // new_uv\n vst1q_s16(dst + i, E);\n }\n for (; i < len; ++i) {\n const int diff_uv = ref[i] - src[i];\n dst[i] += diff_uv;\n }\n}\n\nstatic void SharpYuvFilterRow16_NEON(const int16_t* A, const int16_t* B,\n int len, const uint16_t* best_y,\n uint16_t* out, int bit_depth) {\n const int max_y = (1 << bit_depth) - 1;\n int i;\n const int16x8_t max = vdupq_n_s16(max_y);\n const int16x8_t zero = vdupq_n_s16(0);\n for (i = 0; i + 8 <= len; i += 8) {\n const int16x8_t a0 = vld1q_s16(A + i + 0);\n const int16x8_t a1 = vld1q_s16(A + i + 1);\n const int16x8_t b0 = vld1q_s16(B + i + 0);\n const int16x8_t b1 = vld1q_s16(B + i + 1);\n const int16x8_t a0b1 = vaddq_s16(a0, b1);\n const int16x8_t a1b0 = vaddq_s16(a1, b0);\n const int16x8_t a0a1b0b1 = vaddq_s16(a0b1, a1b0); // A0+A1+B0+B1\n const int16x8_t a0b1_2 = vaddq_s16(a0b1, a0b1); // 2*(A0+B1)\n const int16x8_t a1b0_2 = vaddq_s16(a1b0, a1b0); // 2*(A1+B0)\n const int16x8_t c0 = vshrq_n_s16(vaddq_s16(a0b1_2, a0a1b0b1), 3);\n const int16x8_t c1 = vshrq_n_s16(vaddq_s16(a1b0_2, a0a1b0b1), 3);\n const int16x8_t e0 = vrhaddq_s16(c1, a0);\n const int16x8_t e1 = vrhaddq_s16(c0, a1);\n const int16x8x2_t f = vzipq_s16(e0, e1);\n const int16x8_t g0 = vreinterpretq_s16_u16(vld1q_u16(best_y + 2 * i + 0));\n const int16x8_t g1 = vreinterpretq_s16_u16(vld1q_u16(best_y + 2 * i + 8));\n const int16x8_t h0 = vaddq_s16(g0, f.val[0]);\n const int16x8_t h1 = vaddq_s16(g1, f.val[1]);\n const int16x8_t i0 = vmaxq_s16(vminq_s16(h0, max), zero);\n const int16x8_t i1 = vmaxq_s16(vminq_s16(h1, max), zero);\n vst1q_u16(out + 2 * i + 0, vreinterpretq_u16_s16(i0));\n vst1q_u16(out + 2 * i + 8, vreinterpretq_u16_s16(i1));\n }\n for (; i < len; ++i) {\n const int a0b1 = A[i + 0] + B[i + 1];\n const int a1b0 = A[i + 1] + B[i + 0];\n const int a0a1b0b1 = a0b1 + a1b0 + 8;\n const int v0 = (8 * A[i + 0] + 2 * a1b0 + a0a1b0b1) >> 4;\n const int v1 = (8 * A[i + 1] + 2 * a0b1 + a0a1b0b1) >> 4;\n out[2 * i + 0] = clip_NEON(best_y[2 * i + 0] + v0, max_y);\n out[2 * i + 1] = clip_NEON(best_y[2 * i + 1] + v1, max_y);\n }\n}\n\nstatic void SharpYuvFilterRow32_NEON(const int16_t* A, const int16_t* B,\n int len, const uint16_t* best_y,\n uint16_t* out, int bit_depth) {\n const int max_y = (1 << bit_depth) - 1;\n int i;\n const uint16x8_t max = vdupq_n_u16(max_y);\n for (i = 0; i + 4 <= len; i += 4) {\n const int16x4_t a0 = vld1_s16(A + i + 0);\n const int16x4_t a1 = vld1_s16(A + i + 1);\n const int16x4_t b0 = vld1_s16(B + i + 0);\n const int16x4_t b1 = vld1_s16(B + i + 1);\n const int32x4_t a0b1 = vaddl_s16(a0, b1);\n const int32x4_t a1b0 = vaddl_s16(a1, b0);\n const int32x4_t a0a1b0b1 = vaddq_s32(a0b1, a1b0); // A0+A1+B0+B1\n const int32x4_t a0b1_2 = vaddq_s32(a0b1, a0b1); // 2*(A0+B1)\n const int32x4_t a1b0_2 = vaddq_s32(a1b0, a1b0); // 2*(A1+B0)\n const int32x4_t c0 = vshrq_n_s32(vaddq_s32(a0b1_2, a0a1b0b1), 3);\n const int32x4_t c1 = vshrq_n_s32(vaddq_s32(a1b0_2, a0a1b0b1), 3);\n const int32x4_t e0 = vrhaddq_s32(c1, vmovl_s16(a0));\n const int32x4_t e1 = vrhaddq_s32(c0, vmovl_s16(a1));\n const int32x4x2_t f = vzipq_s32(e0, e1);\n\n const int16x8_t g = vreinterpretq_s16_u16(vld1q_u16(best_y + 2 * i));\n const int32x4_t h0 = vaddw_s16(f.val[0], vget_low_s16(g));\n const int32x4_t h1 = vaddw_s16(f.val[1], vget_high_s16(g));\n const uint16x8_t i_16 = vcombine_u16(vqmovun_s32(h0), vqmovun_s32(h1));\n const uint16x8_t i_clamped = vminq_u16(i_16, max);\n vst1q_u16(out + 2 * i + 0, i_clamped);\n }\n for (; i < len; ++i) {\n const int a0b1 = A[i + 0] + B[i + 1];\n const int a1b0 = A[i + 1] + B[i + 0];\n const int a0a1b0b1 = a0b1 + a1b0 + 8;\n const int v0 = (8 * A[i + 0] + 2 * a1b0 + a0a1b0b1) >> 4;\n const int v1 = (8 * A[i + 1] + 2 * a0b1 + a0a1b0b1) >> 4;\n out[2 * i + 0] = clip_NEON(best_y[2 * i + 0] + v0, max_y);\n out[2 * i + 1] = clip_NEON(best_y[2 * i + 1] + v1, max_y);\n }\n}\n\nstatic void SharpYuvFilterRow_NEON(const int16_t* A, const int16_t* B, int len,\n const uint16_t* best_y, uint16_t* out,\n int bit_depth) {\n if (bit_depth <= 10) {\n SharpYuvFilterRow16_NEON(A, B, len, best_y, out, bit_depth);\n } else {\n SharpYuvFilterRow32_NEON(A, B, len, best_y, out, bit_depth);\n }\n}\n\n//------------------------------------------------------------------------------\n\nextern void InitSharpYuvNEON(void);\n\nWEBP_TSAN_IGNORE_FUNCTION void InitSharpYuvNEON(void) {\n SharpYuvUpdateY = SharpYuvUpdateY_NEON;\n SharpYuvUpdateRGB = SharpYuvUpdateRGB_NEON;\n SharpYuvFilterRow = SharpYuvFilterRow_NEON;\n}\n\n#else // !WEBP_USE_NEON\n\nextern void InitSharpYuvNEON(void);\n\nvoid InitSharpYuvNEON(void) {}\n\n#endif // WEBP_USE_NEON\n"}}},{"rowIdx":22999,"cells":{"text":{"kind":"string","value":"// Copyright 2022 Google Inc. All Rights Reserved.\n//\n// Use of this source code is governed by a BSD-style license\n// that can be found in the COPYING file in the root of the source\n// tree. An additional intellectual property rights grant can be found\n// in the file PATENTS. All contributing project authors may\n// be found in the AUTHORS file in the root of the source tree.\n// -----------------------------------------------------------------------------\n//\n// Speed-critical functions for Sharp YUV.\n//\n// Author: Skal (pascal.massimino@gmail.com)\n\n#include \"sharpyuv/sharpyuv_dsp.h\"\n\n#if defined(WEBP_USE_SSE2)\n#include <emmintrin.h>\n\n#include <stdlib.h>\n\n#include \"src/dsp/cpu.h\"\n#include \"src/webp/types.h\"\n\nstatic uint16_t clip_SSE2(int v, int max) {\n return (v < 0) ? 0 : (v > max) ? max : (uint16_t)v;\n}\n\nstatic uint64_t SharpYuvUpdateY_SSE2(const uint16_t* ref, const uint16_t* src,\n uint16_t* dst, int len, int bit_depth) {\n const int max_y = (1 << bit_depth) - 1;\n uint64_t diff = 0;\n uint32_t tmp[4];\n int i;\n const __m128i zero = _mm_setzero_si128();\n const __m128i max = _mm_set1_epi16(max_y);\n const __m128i one = _mm_set1_epi16(1);\n __m128i sum = zero;\n\n for (i = 0; i + 8 <= len; i += 8) {\n const __m128i A = _mm_loadu_si128((const __m128i*)(ref + i));\n const __m128i B = _mm_loadu_si128((const __m128i*)(src + i));\n const __m128i C = _mm_loadu_si128((const __m128i*)(dst + i));\n const __m128i D = _mm_sub_epi16(A, B); // diff_y\n const __m128i E = _mm_cmpgt_epi16(zero, D); // sign (-1 or 0)\n const __m128i F = _mm_add_epi16(C, D); // new_y\n const __m128i G = _mm_or_si128(E, one); // -1 or 1\n const __m128i H = _mm_max_epi16(_mm_min_epi16(F, max), zero);\n const __m128i I = _mm_madd_epi16(D, G); // sum(abs(...))\n _mm_storeu_si128((__m128i*)(dst + i), H);\n sum = _mm_add_epi32(sum, I);\n }\n _mm_storeu_si128((__m128i*)tmp, sum);\n diff = tmp[3] + tmp[2] + tmp[1] + tmp[0];\n for (; i < len; ++i) {\n const int diff_y = ref[i] - src[i];\n const int new_y = (int)dst[i] + diff_y;\n dst[i] = clip_SSE2(new_y, max_y);\n diff += (uint64_t)abs(diff_y);\n }\n return diff;\n}\n\nstatic void SharpYuvUpdateRGB_SSE2(const int16_t* ref, const int16_t* src,\n int16_t* dst, int len) {\n int i = 0;\n for (i = 0; i + 8 <= len; i += 8) {\n const __m128i A = _mm_loadu_si128((const __m128i*)(ref + i));\n const __m128i B = _mm_loadu_si128((const __m128i*)(src + i));\n const __m128i C = _mm_loadu_si128((const __m128i*)(dst + i));\n const __m128i D = _mm_sub_epi16(A, B); // diff_uv\n const __m128i E = _mm_add_epi16(C, D); // new_uv\n _mm_storeu_si128((__m128i*)(dst + i), E);\n }\n for (; i < len; ++i) {\n const int diff_uv = ref[i] - src[i];\n dst[i] += diff_uv;\n }\n}\n\nstatic void SharpYuvFilterRow16_SSE2(const int16_t* A, const int16_t* B,\n int len, const uint16_t* best_y,\n uint16_t* out, int bit_depth) {\n const int max_y = (1 << bit_depth) - 1;\n int i;\n const __m128i kCst8 = _mm_set1_epi16(8);\n const __m128i max = _mm_set1_epi16(max_y);\n const __m128i zero = _mm_setzero_si128();\n for (i = 0; i + 8 <= len; i += 8) {\n const __m128i a0 = _mm_loadu_si128((const __m128i*)(A + i + 0));\n const __m128i a1 = _mm_loadu_si128((const __m128i*)(A + i + 1));\n const __m128i b0 = _mm_loadu_si128((const __m128i*)(B + i + 0));\n const __m128i b1 = _mm_loadu_si128((const __m128i*)(B + i + 1));\n const __m128i a0b1 = _mm_add_epi16(a0, b1);\n const __m128i a1b0 = _mm_add_epi16(a1, b0);\n const __m128i a0a1b0b1 = _mm_add_epi16(a0b1, a1b0); // A0+A1+B0+B1\n const __m128i a0a1b0b1_8 = _mm_add_epi16(a0a1b0b1, kCst8);\n const __m128i a0b1_2 = _mm_add_epi16(a0b1, a0b1); // 2*(A0+B1)\n const __m128i a1b0_2 = _mm_add_epi16(a1b0, a1b0); // 2*(A1+B0)\n const __m128i c0 = _mm_srai_epi16(_mm_add_epi16(a0b1_2, a0a1b0b1_8), 3);\n const __m128i c1 = _mm_srai_epi16(_mm_add_epi16(a1b0_2, a0a1b0b1_8), 3);\n const __m128i d0 = _mm_add_epi16(c1, a0);\n const __m128i d1 = _mm_add_epi16(c0, a1);\n const __m128i e0 = _mm_srai_epi16(d0, 1);\n const __m128i e1 = _mm_srai_epi16(d1, 1);\n const __m128i f0 = _mm_unpacklo_epi16(e0, e1);\n const __m128i f1 = _mm_unpackhi_epi16(e0, e1);\n const __m128i g0 = _mm_loadu_si128((const __m128i*)(best_y + 2 * i + 0));\n const __m128i g1 = _mm_loadu_si128((const __m128i*)(best_y + 2 * i + 8));\n const __m128i h0 = _mm_add_epi16(g0, f0);\n const __m128i h1 = _mm_add_epi16(g1, f1);\n const __m128i i0 = _mm_max_epi16(_mm_min_epi16(h0, max), zero);\n const __m128i i1 = _mm_max_epi16(_mm_min_epi16(h1, max), zero);\n _mm_storeu_si128((__m128i*)(out + 2 * i + 0), i0);\n _mm_storeu_si128((__m128i*)(out + 2 * i + 8), i1);\n }\n for (; i < len; ++i) {\n // (9 * A0 + 3 * A1 + 3 * B0 + B1 + 8) >> 4 =\n // = (8 * A0 + 2 * (A1 + B0) + (A0 + A1 + B0 + B1 + 8)) >> 4\n // We reuse the common sub-expressions.\n const int a0b1 = A[i + 0] + B[i + 1];\n const int a1b0 = A[i + 1] + B[i + 0];\n const int a0a1b0b1 = a0b1 + a1b0 + 8;\n const int v0 = (8 * A[i + 0] + 2 * a1b0 + a0a1b0b1) >> 4;\n const int v1 = (8 * A[i + 1] + 2 * a0b1 + a0a1b0b1) >> 4;\n out[2 * i + 0] = clip_SSE2(best_y[2 * i + 0] + v0, max_y);\n out[2 * i + 1] = clip_SSE2(best_y[2 * i + 1] + v1, max_y);\n }\n}\n\nstatic WEBP_INLINE __m128i s16_to_s32(__m128i in) {\n return _mm_srai_epi32(_mm_unpacklo_epi16(in, in), 16);\n}\n\nstatic void SharpYuvFilterRow32_SSE2(const int16_t* A, const int16_t* B,\n int len, const uint16_t* best_y,\n uint16_t* out, int bit_depth) {\n const int max_y = (1 << bit_depth) - 1;\n int i;\n const __m128i kCst8 = _mm_set1_epi32(8);\n const __m128i max = _mm_set1_epi16(max_y);\n const __m128i zero = _mm_setzero_si128();\n for (i = 0; i + 4 <= len; i += 4) {\n const __m128i a0 = s16_to_s32(_mm_loadl_epi64((const __m128i*)(A + i + 0)));\n const __m128i a1 = s16_to_s32(_mm_loadl_epi64((const __m128i*)(A + i + 1)));\n const __m128i b0 = s16_to_s32(_mm_loadl_epi64((const __m128i*)(B + i + 0)));\n const __m128i b1 = s16_to_s32(_mm_loadl_epi64((const __m128i*)(B + i + 1)));\n const __m128i a0b1 = _mm_add_epi32(a0, b1);\n const __m128i a1b0 = _mm_add_epi32(a1, b0);\n const __m128i a0a1b0b1 = _mm_add_epi32(a0b1, a1b0); // A0+A1+B0+B1\n const __m128i a0a1b0b1_8 = _mm_add_epi32(a0a1b0b1, kCst8);\n const __m128i a0b1_2 = _mm_add_epi32(a0b1, a0b1); // 2*(A0+B1)\n const __m128i a1b0_2 = _mm_add_epi32(a1b0, a1b0); // 2*(A1+B0)\n const __m128i c0 = _mm_srai_epi32(_mm_add_epi32(a0b1_2, a0a1b0b1_8), 3);\n const __m128i c1 = _mm_srai_epi32(_mm_add_epi32(a1b0_2, a0a1b0b1_8), 3);\n const __m128i d0 = _mm_add_epi32(c1, a0);\n const __m128i d1 = _mm_add_epi32(c0, a1);\n const __m128i e0 = _mm_srai_epi32(d0, 1);\n const __m128i e1 = _mm_srai_epi32(d1, 1);\n const __m128i f0 = _mm_unpacklo_epi32(e0, e1);\n const __m128i f1 = _mm_unpackhi_epi32(e0, e1);\n const __m128i g = _mm_loadu_si128((const __m128i*)(best_y + 2 * i + 0));\n const __m128i h_16 = _mm_add_epi16(g, _mm_packs_epi32(f0, f1));\n const __m128i final = _mm_max_epi16(_mm_min_epi16(h_16, max), zero);\n _mm_storeu_si128((__m128i*)(out + 2 * i + 0), final);\n }\n for (; i < len; ++i) {\n // (9 * A0 + 3 * A1 + 3 * B0 + B1 + 8) >> 4 =\n // = (8 * A0 + 2 * (A1 + B0) + (A0 + A1 + B0 + B1 + 8)) >> 4\n // We reuse the common sub-expressions.\n const int a0b1 = A[i + 0] + B[i + 1];\n const int a1b0 = A[i + 1] + B[i + 0];\n const int a0a1b0b1 = a0b1 + a1b0 + 8;\n const int v0 = (8 * A[i + 0] + 2 * a1b0 + a0a1b0b1) >> 4;\n const int v1 = (8 * A[i + 1] + 2 * a0b1 + a0a1b0b1) >> 4;\n out[2 * i + 0] = clip_SSE2(best_y[2 * i + 0] + v0, max_y);\n out[2 * i + 1] = clip_SSE2(best_y[2 * i + 1] + v1, max_y);\n }\n}\n\nstatic void SharpYuvFilterRow_SSE2(const int16_t* A, const int16_t* B, int len,\n const uint16_t* best_y, uint16_t* out,\n int bit_depth) {\n if (bit_depth <= 10) {\n SharpYuvFilterRow16_SSE2(A, B, len, best_y, out, bit_depth);\n } else {\n SharpYuvFilterRow32_SSE2(A, B, len, best_y, out, bit_depth);\n }\n}\n\n//------------------------------------------------------------------------------\n\nextern void InitSharpYuvSSE2(void);\n\nWEBP_TSAN_IGNORE_FUNCTION void InitSharpYuvSSE2(void) {\n SharpYuvUpdateY = SharpYuvUpdateY_SSE2;\n SharpYuvUpdateRGB = SharpYuvUpdateRGB_SSE2;\n SharpYuvFilterRow = SharpYuvFilterRow_SSE2;\n}\n#else // !WEBP_USE_SSE2\n\nextern void InitSharpYuvSSE2(void);\n\nvoid InitSharpYuvSSE2(void) {}\n\n#endif // WEBP_USE_SSE2\n"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":229,"numItemsPerPage":100,"numTotalItems":368324,"offset":22900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6Im1sR1pFYktIVHRVSGRhX1RRdEczQ0N1S3k5ME9Qd25DNHY5elRjM3FVYzgifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MzkyMjEzMSwianRpIjoiZWFmNDBmNjctNTY3Zi00ZTQ2LWEwMzgtOWY5MWUyZmY2ODkyIiwic3ViIjoiL2RhdGFzZXRzL1dob2xlc29tZWlzbGFuZC9jcHAtbWl0LWdpdGh1Yi1zZWFyY2gtY29kZS1pbi1yZXBvcyIsImV4cCI6MTc4MzkyNTczMSwiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.E4UA99HU_kInh1bBMio9RIdUEsP5FR_xZyUZ8El9o3Q31r2JHK-pTMn8FMJPYaQWnYczhQCMpkejZpw0MXNNCw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":368324,"numBytesParquet":1417414927}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
text stringlengths 1 24.5M |
|---|
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lice... |
#pragma once
#include "rapidjson/rapidjson.h"
#include "rapidjson/document.h"
|
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lice... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lice... |
// Tencent is pleased to support the open source community by making RapidJSON available->
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip-> All rights reserved->
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License-> You may ... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lice... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// (C) Copyright IBM Corporation 2021
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://opensource.org... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lice... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lice... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lice... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lice... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lice... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lic... |
// Tencent is pleased to support the open source community by making RapidJSON available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
//
// Licensed under the MIT License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the Lice... |
// ISO C9x compliant inttypes.h for Microsoft Visual Studio
// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
//
// Copyright (c) 2006-2013 Alexander Chemeris
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following cond... |
// ISO C9x compliant stdint.h for Microsoft Visual Studio
// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
//
// Copyright (c) 2006-2013 Alexander Chemeris
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following condit... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
/**
@defgroup detour Detour
Members in this module are wrappers around the standard math library
*/
#ifndef DETOURMATH_H
#define DETOURMATH_H
#include <math.h>
inline float dtMathFabsf(float x) { return fabsf(x); }
inline float dtMathSqrtf(float x) { return sqrtf(x); }
inline float dtMathFloorf(float x) { return fl... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
#include "DetourTileCache.h"
#include "DetourTileCacheBuilder.h"
#include "DetourNavMeshBuilder.h"
#include "DetourNavMesh.h"
#include "DetourCommon.h"
#include "DetourMath.h"
#include "DetourAlloc.h"
#include "DetourAssert.h"
#include <string.h>
#include <new>
dtTileCache* dtAllocTileCache()
{
void* mem = dtAlloc(si... |
#ifndef DETOURTILECACHE_H
#define DETOURTILECACHE_H
#include "DetourStatus.h"
typedef unsigned int dtObstacleRef;
typedef unsigned int dtCompressedTileRef;
/// Flags for addTile
enum dtCompressedTileFlags
{
DT_COMPRESSEDTILE_FREE_DATA = 0x01 ///< Navmesh owns the tile memory and should free it.
};
struct dtCompres... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose... |
/**
* MIT License
*
* Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitati... |
/**
* MIT License
*
* Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitati... |
/**
* MIT License
*
* Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitati... |
/**
* MIT License
*
* Copyright (c) 2017 Thibaut Goetghebuer-Planchon <tessil@gmx.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitati... |
/* auto-generated on 2025-11-03 11:03:21 -0500. version 4.2.1 Do not edit! */
/* including simdjson.cpp: */
/* begin file simdjson.cpp */
#define SIMDJSON_SRC_SIMDJSON_CPP
/* including base.h: #include <base.h> */
/* begin file base.h */
#ifndef SIMDJSON_SRC_BASE_H
#define SIMDJSON_SRC_BASE_H
/* including simdjson/b... |
/* auto-generated on 2025-11-03 11:03:21 -0500. version 4.2.1 Do not edit! */
/* including simdjson.h: */
/* begin file simdjson.h */
#ifndef SIMDJSON_H
#define SIMDJSON_H
/**
* @mainpage
*
* Check the [README.md](https://github.com/simdjson/simdjson/blob/master/README.md#simdjson--parsing-gigabytes-of-json-per-se... |
/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb
no warranty implied; use at your own risk
Do this:
#define STB_IMAGE_IMPLEMENTATION
before you include this file in *one* C or C++ file to create the implementation.
// i.e. it should look like... |
/* ioapi.c -- IO base function header for compress/uncompress .zip
part of the MiniZip project
Copyright (C) 2012-2017 Nathan Moinvaziri
https://github.com/nmoinvaz/minizip
Modifications for Zip64 support
Copyright (C) 2009-2010 Mathias Svensson
http://result42.com
Copyright (C) 1998-2010 Gi... |
/* ioapi.h -- IO base function header for compress/uncompress .zip
part of the MiniZip project
Copyright (C) 2012-2017 Nathan Moinvaziri
https://github.com/nmoinvaz/minizip
Copyright (C) 2009-2010 Mathias Svensson
Modifications for Zip64 support
http://result42.com
Copyright (C) 1998-2010 Gi... |
/* ioapi_mem.c -- IO base function header for compress/uncompress .zip
files using zlib + zip or unzip API
This version of ioapi is designed to access memory rather than files.
We do use a region of memory to put data in to and take it out of. We do
not have auto-extending buffers and do not inform anyone ... |
/* ioapi_mem.h -- IO base function header for compress/uncompress .zip
files using zlib + zip or unzip API
This version of ioapi is designed to access memory rather than files.
We do use a region of memory to put data in to and take it out of.
Copyright (C) 2012-2017 Nathan Moinvaziri (https://github.com/... |
/* unzip.c -- IO for uncompress .zip files using zlib
Version 1.2.0, September 16th, 2017
part of the MiniZip project
Copyright (C) 2010-2017 Nathan Moinvaziri
Modifications for AES, PKWARE disk spanning
https://github.com/nmoinvaz/minizip
Copyright (C) 2009-2010 Mathias Svensson
Modificatio... |
/* unzip.h -- IO for uncompress .zip files using zlib
Version 1.2.0, September 16th, 2017
part of the MiniZip project
Copyright (C) 2012-2017 Nathan Moinvaziri
https://github.com/nmoinvaz/minizip
Copyright (C) 2009-2010 Mathias Svensson
Modifications for Zip64 support on both zip and unzip
h... |
// Copyright 2022 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be... |
// Copyright 2022 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be... |
// Copyright 2022 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be... |
// Copyright 2022 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be... |
// Copyright 2022 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be... |
// Copyright 2022 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be... |
// Copyright 2022 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be... |
// Copyright 2022 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be... |
// Copyright 2022 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be... |
// Copyright 2022 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be... |
// Copyright 2022 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be... |
// Copyright 2022 Google Inc. All Rights Reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the COPYING file in the root of the source
// tree. An additional intellectual property rights grant can be found
// in the file PATENTS. All contributing project authors may
// be... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.