Add qrcode test

[Issue type] New

Add qrcode test from zint upstream repository.
Link: https://github.com/zint/zint/blob/9e06845c93f042a775f59c64bcd92e934f8963da/backend/tests/test_qr.c

Change-Id: I7e7e1053c3fcf5ba454e4615b27e0ca6d1e0e994
Signed-off-by: Kwanghoon Son <k.son@samsung.com>

4 files changed, 3390 insertions, 5 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1a587b5..f9f7698 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,6 +4,7 @@ cmake_minimum_required(VERSION 2.6)
 project(zint-package)
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
+option(ENABLE_TEST "Build gtest" ON)
 
 #set(CMAKE_VERBOSE_MAKEFILE ON)
 #comment or remove the above line before release
@@ -12,7 +13,7 @@ if ("${ARCH}" MATCHES "aarch64")
 MESSAGE(${ARCH})
 set(LIB_SUFFIX "64")
 else ("${ARCH}" MATCHES "aarch64")
-MESSAGE(${ARCH})
+MESSAGE("${ARCH}")
 endif ("${ARCH}" MATCHES "aarch64")
 
 add_definitions (-DZINT_VERSION=\"${ZINT_VERSION}\" -Wno-unused-variable -Wall )
@@ -36,6 +37,11 @@ endif (CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_GNUCC)
 
 add_subdirectory(backend)
 
+if(ENABLE_TEST)
+enable_testing()
+add_subdirectory(test)
+endif()
+
 CONFIGURE_FILE(
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
   "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
@@ -50,6 +56,4 @@ install(FILES cmake/modules/FindZint.cmake DESTINATION /usr/share/cmake/Modules
 # advantage of this.
 IF(NOT ZINT_HAS_BEEN_RUN_BEFORE)
     SET(ZINT_HAS_BEEN_RUN_BEFORE 1 CACHE INTERNAL "Flag to track whether this is the first time running CMake or if CMake has been configured before")
-ENDIF(NOT ZINT_HAS_BEEN_RUN_BEFORE)
-
-
+ENDIF(NOT ZINT_HAS_BEEN_RUN_BEFORE)
\ No newline at end of file
diff --git a/packaging/zint.spec b/packaging/zint.spec
index 261bf75..c129237 100644
--- a/packaging/zint.spec
+++ b/packaging/zint.spec
@@ -49,7 +49,8 @@ ARCH=aarch64
 ARCH=arm
 %endif
 
-cmake . -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER} -DARCH=${ARCH} -DENABLE_DEBUG=OFF
+cmake . -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER} \
+-DARCH=${ARCH} -DENABLE_DEBUG=OFF -DENABLE_TEST=OFF
 make VERBOSE=1
 
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
new file mode 100644
index 0000000..0a68123
--- /dev/null
+++ b/test/CMakeLists.txt
@@ -0,0 +1,9 @@
+add_executable(
+  zint_test
+  test_qr.cpp
+)
+target_link_libraries(
+  zint_test
+  zint
+  gtest gtest_main pthread png
+)
\ No newline at end of file
diff --git a/test/test_qr.cpp b/test/test_qr.cpp
new file mode 100644
index 0000000..30400de
--- /dev/null
+++ b/test/test_qr.cpp
@@ -0,0 +1,3371 @@
+/*
+    libzint - the open source barcode library
+    Copyright (C) 2019-2022 Robin Stuart <rstuart114@gmail.com>
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+    3. Neither the name of the project nor the names of its contributors
+       may be used to endorse or promote products derived from this software
+       without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+    ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+    OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+    OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+ */
+/* SPDX-License-Identifier: BSD-3-Clause */
+
+#include <gtest/gtest.h>
+#include <zint.h>
+#include <list>
+
+/* Returns true (1) if a module is dark/black, otherwise false (0) */
+#define module_is_set(s, y, x) (((s)->encoded_data[(y)][(x) >> 3] >> ((x)&0x07)) & 1)
+
+/* Returns true (1-8) if a module is colour, otherwise false (0) */
+#define module_colour_is_set(s, y, x) ((s)->encoded_data[(y)][(x)])
+
+/* Sets a module to a colour */
+#define set_module_colour(s, y, x, c)      \
+    do                                     \
+    {                                      \
+        (s)->encoded_data[(y)][(x)] = (c); \
+    } while (0)
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) ((int)(sizeof(x) / sizeof((x)[0])))
+#endif
+
+#define FAST_MODE 0x0080 /* Use faster if less optimal encodation or other shortcuts if available */
+                         /* Note: affects DATAMATRIX, MICROPDF417, PDF417, QRCODE & UPNQR only */
+
+#define ZINT_FULL_MULTIBYTE 200    /* Enable Kanji/Hanzi compression for Latin-1 & binary data */
+#define ZINT_WARN_NONCOMPLIANT 4   /* Symbol created not compliant with standards */
+#define ZINT_ERROR_FILE_WRITE 12   /* Error writing to output file */
+#define ZINT_ERROR_USES_ECI 13     /* Error counterpart of warning if WARN_FAIL_ALL set (see below) */
+#define ZINT_ERROR_NONCOMPLIANT 14 /* Error counterpart of warning if WARN_FAIL_ALL set */
+
+/* Whether 2 module dumps are the same */
+int testUtilModulesCmp(const struct zint_symbol *symbol, const char *expected, int *width, int *row)
+{
+    const char *e = expected;
+    const char *ep = expected + strlen(expected);
+    int r, w = 0;
+    if (symbol->symbology == BARCODE_ULTRA)
+    {
+        for (r = 0; r < symbol->rows && e < ep; r++)
+        {
+            for (w = 0; w < symbol->width && e < ep; w++)
+            {
+                if (module_colour_is_set(symbol, r, w) + '0' != *e)
+                {
+                    *row = r;
+                    *width = w;
+                    return 1 /*fail*/;
+                }
+                e++;
+            }
+        }
+    }
+    else
+    {
+        for (r = 0; r < symbol->rows && e < ep; r++)
+        {
+            for (w = 0; w < symbol->width && e < ep; w++)
+            {
+                if (module_is_set(symbol, r, w) + '0' != *e)
+                {
+                    *row = r;
+                    *width = w;
+                    return 1 /*fail*/;
+                }
+                e++;
+            }
+        }
+    }
+    *row = r;
+    *width = w;
+    return e != ep || r != symbol->rows || w != symbol->width ? 1 /*fail*/ : 0 /*success*/;
+}
+
+/* Helper to set common symbol fields */
+int testUtilSetSymbol(struct zint_symbol *symbol, int symbology, int input_mode, int eci, int option_1, int option_2,
+                      int option_3, int output_options, const char *data, int length, int debug)
+{
+    symbol->symbology = symbology;
+    if (input_mode != -1)
+    {
+        symbol->input_mode = input_mode;
+    }
+    if (eci != -1)
+    {
+        symbol->eci = eci;
+    }
+    if (option_1 != -1)
+    {
+        symbol->option_1 = option_1;
+    }
+    if (option_2 != -1)
+    {
+        symbol->option_2 = option_2;
+    }
+    if (option_3 != -1)
+    {
+        symbol->option_3 = option_3;
+    }
+    if (output_options != -1)
+    {
+        symbol->output_options = output_options;
+    }
+    symbol->debug |= debug;
+    if (length == -1)
+    {
+        length = (int)strlen(data);
+    }
+
+    return length;
+}
+
+struct zint_structapp
+{
+    int index;   /* Position in Structured Append sequence, 1-based. Must be <= `count` */
+    int count;   /* Number of symbols in Structured Append sequence. Set >= 2 to add SA Info */
+    char id[32]; /* Optional ID to distinguish sequence, ASCII, NUL-terminated unless max 32 long */
+};
+
+struct item
+{
+    int symbology;
+    int input_mode;
+    int eci;
+    int option_1;
+    int option_2;
+    int option_3;
+    struct zint_structapp structapp;
+    const char *data;
+    int length;
+    int ret;
+
+    int expected_rows;
+    int expected_width;
+    int bwipp_cmp;
+    const char *comment;
+    const char *expected;
+};
+
+/* や U+3084 kanji, in Shift JIS 0x82E2 (\202\342), UTF-8 E38284; its 2nd byte 0xE2 + 0x40-FC also form Shift JIS */
+struct item items[] = {
+    /*  0*/ {BARCODE_QRCODE, UNICODE_MODE, -1, -1, -1, -1, {0, 0, ""}, "QR Code Symbol", -1, 0, 21, 21, 0, "ISO 18004 Figure 1 **NOT SAME** uses mask 110 instead of 101; BWIPP uses 101", "111111101001101111111"
+                                                                                                                                                                                           "100000101001101000001"
+                                                                                                                                                                                           "101110101100101011101"
+                                                                                                                                                                                           "101110100010001011101"
+                                                                                                                                                                                           "101110101001101011101"
+                                                                                                                                                                                           "100000100001101000001"
+                                                                                                                                                                                           "111111101010101111111"
+                                                                                                                                                                                           "000000000100100000000"
+                                                                                                                                                                                           "100111111101010010111"
+                                                                                                                                                                                           "100010001110001000111"
+                                                                                                                                                                                           "010100110000101101011"
+                                                                                                                                                                                           "110111001000010111110"
+                                                                                                                                                                                           "011111111110001011011"
+                                                                                                                                                                                           "000000001000011010101"
+                                                                                                                                                                                           "111111101101101010100"
+                                                                                                                                                                                           "100000101010011011100"
+                                                                                                                                                                                           "101110101001110001110"
+                                                                                                                                                                                           "101110101111001001100"
+                                                                                                                                                                                           "101110100100101010011"
+                                                                                                                                                                                           "100000100001101111111"
+                                                                                                                                                                                           "111111101001011000000"},
+    /*  1*/ {BARCODE_QRCODE, UNICODE_MODE, -1, -1, -1, 6 << 8, {0, 0, ""}, "QR Code Symbol", -1, 0, 21, 21, 1, "ISO 18004 Figure 1, explicit mask 101, same", "111111100001101111111"
+                                                                                                                                                              "100000101001101000001"
+                                                                                                                                                              "101110101110101011101"
+                                                                                                                                                              "101110101010001011101"
+                                                                                                                                                              "101110100000101011101"
+                                                                                                                                                              "100000100010101000001"
+                                                                                                                                                              "111111101010101111111"
+                                                                                                                                                              "000000001100100000000"
+                                                                                                                                                              "100000101111011001110"
+                                                                                                                                                              "100010001110001000111"
+                                                                                                                                                              "011101111001100100010"
+                                                                                                                                                              "110100001011010100110"
+                                                                                                                                                              "011111111110001011011"
+                                                                                                                                                              "000000001000000010110"
+                                                                                                                                                              "111111100111111000110"
+                                                                                                                                                              "100000100010011011100"
+                                                                                                                                                              "101110100000111000111"
+                                                                                                                                                              "101110100100001010100"
+                                                                                                                                                              "101110100100101010011"
+                                                                                                                                                              "100000100001110111100"
+                                                                                                                                                              "111111101011001010010"},
+    /*  2*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 2, -1, -1, {0, 0, ""}, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ", -1, 0, 33, 33, 1, "ISO 18004 Figure 29 (top), same (mask 100)", "111111101100110010010010101111111"
+                                                                                                                                                                                                        "100000100010111010111000101000001"
+                                                                                                                                                                                                        "101110100000001101101100001011101"
+                                                                                                                                                                                                        "101110101010000111000110001011101"
+                                                                                                                                                                                                        "101110101101100011010010001011101"
+                                                                                                                                                                                                        "100000101100010100001101101000001"
+                                                                                                                                                                                                        "111111101010101010101010101111111"
+                                                                                                                                                                                                        "000000001010000000011100100000000"
+                                                                                                                                                                                                        "100010111100001100100011011111001"
+                                                                                                                                                                                                        "100101000111001001000110000101100"
+                                                                                                                                                                                                        "010001100011111010101000011011001"
+                                                                                                                                                                                                        "101101011101010010000010010000000"
+                                                                                                                                                                                                        "001111110011010110010011101001100"
+                                                                                                                                                                                                        "011001000101001000111100110101001"
+                                                                                                                                                                                                        "101001111001111101001111000110111"
+                                                                                                                                                                                                        "100100010001000111100101111100000"
+                                                                                                                                                                                                        "110010111101110000011110111111100"
+                                                                                                                                                                                                        "010000010111100010001000010000111"
+                                                                                                                                                                                                        "111111111111010101000110010001111"
+                                                                                                                                                                                                        "001100010000000111100101010101110"
+                                                                                                                                                                                                        "111101111011101000111001010010001"
+                                                                                                                                                                                                        "100110000101001010010111000100001"
+                                                                                                                                                                                                        "000110111110111010010001011001000"
+                                                                                                                                                                                                        "001011010011101000011111011101111"
+                                                                                                                                                                                                        "111011111000010111001001111110000"
+                                                                                                                                                                                                        "000000001110110011111100100010100"
+                                                                                                                                                                                                        "111111101000110100101000101010011"
+                                                                                                                                                                                                        "100000100001010010001011100010000"
+                                                                                                                                                                                                        "101110101111011010000010111111100"
+                                                                                                                                                                                                        "101110100000111000111100000000101"
+                                                                                                                                                                                                        "101110100101010100001000010110100"
+                                                                                                                                                                                                        "100000100010110111000110101001001"
+                                                                                                                                                                                                        "111111101101101011010000111100011"},
+    /*  3*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 2, -1, -1, {1, 4, "1"}, "ABCDEFGHIJKLMN", -1, 0, 21, 21, 1, "ISO 18004 Figure 29 (bottom 1st), same", "111111100110001111111"
+                                                                                                                                                     "100000101001101000001"
+                                                                                                                                                     "101110100010001011101"
+                                                                                                                                                     "101110100110001011101"
+                                                                                                                                                     "101110101110101011101"
+                                                                                                                                                     "100000100110101000001"
+                                                                                                                                                     "111111101010101111111"
+                                                                                                                                                     "000000000011100000000"
+                                                                                                                                                     "101010100011000010010"
+                                                                                                                                                     "100011011111010011011"
+                                                                                                                                                     "100010111110101110101"
+                                                                                                                                                     "010110000101011000000"
+                                                                                                                                                     "110000111110110111001"
+                                                                                                                                                     "000000001011010001010"
+                                                                                                                                                     "111111100101110011101"
+                                                                                                                                                     "100000100100001110101"
+                                                                                                                                                     "101110101101011000101"
+                                                                                                                                                     "101110100110100110110"
+                                                                                                                                                     "101110101011010011101"
+                                                                                                                                                     "100000100101110000001"
+                                                                                                                                                     "111111101000110110101"},
+    /*  4*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 2, -1, 8 << 8, {2, 4, "1"}, "OPQRSTUVWXYZ0123", -1, 0, 21, 21, 1, "ISO 18004 Figure 29 (bottom 2nd), same with explicit mask 111 (auto 011)", "111111100011101111111"
+                                                                                                                                                                                             "100000100001101000001"
+                                                                                                                                                                                             "101110100001101011101"
+                                                                                                                                                                                             "101110100101101011101"
+                                                                                                                                                                                             "101110100100101011101"
+                                                                                                                                                                                             "100000101000001000001"
+                                                                                                                                                                                             "111111101010101111111"
+                                                                                                                                                                                             "000000000111000000000"
+                                                                                                                                                                                             "100101101001010100000"
+                                                                                                                                                                                             "010111001001110011011"
+                                                                                                                                                                                             "011110101011010010111"
+                                                                                                                                                                                             "010100011110100110101"
+                                                                                                                                                                                             "011100101100111110101"
+                                                                                                                                                                                             "000000001011011100000"
+                                                                                                                                                                                             "111111100110100011100"
+                                                                                                                                                                                             "100000101001010100001"
+                                                                                                                                                                                             "101110100100101101111"
+                                                                                                                                                                                             "101110101100000010001"
+                                                                                                                                                                                             "101110100110101001101"
+                                                                                                                                                                                             "100000100111100011111"
+                                                                                                                                                                                             "111111101011011110100"},
+    /*  5*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 2, -1, -1, {3, 4, "1"}, "456789ABCDEFGHIJ", -1, 0, 21, 21, 1, "ISO 18004 Figure 29 (bottom 3rd), same", "111111100101001111111"
+                                                                                                                                                       "100000100011101000001"
+                                                                                                                                                       "101110100010101011101"
+                                                                                                                                                       "101110100111101011101"
+                                                                                                                                                       "101110100010101011101"
+                                                                                                                                                       "100000101110001000001"
+                                                                                                                                                       "111111101010101111111"
+                                                                                                                                                       "000000000001000000000"
+                                                                                                                                                       "100101101101010100000"
+                                                                                                                                                       "011011000001100111011"
+                                                                                                                                                       "101010111101010110111"
+                                                                                                                                                       "011001000101010100101"
+                                                                                                                                                       "011111100110000110101"
+                                                                                                                                                       "000000001010000111000"
+                                                                                                                                                       "111111100100101101100"
+                                                                                                                                                       "100000101101011001101"
+                                                                                                                                                       "101110100010001101011"
+                                                                                                                                                       "101110101101101110110"
+                                                                                                                                                       "101110100100011001101"
+                                                                                                                                                       "100000100011100101011"
+                                                                                                                                                       "111111101011000011000"},
+    /*  6*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 2, -1, -1, {4, 4, "1"}, "KLMNOPQRSTUVWXYZ", -1, 0, 21, 21, 1, "ISO 18004 Figure 29 (bottom 4th), same", "111111101011101111111"
+                                                                                                                                                       "100000101010101000001"
+                                                                                                                                                       "101110100011001011101"
+                                                                                                                                                       "101110101100001011101"
+                                                                                                                                                       "101110100111001011101"
+                                                                                                                                                       "100000100110001000001"
+                                                                                                                                                       "111111101010101111111"
+                                                                                                                                                       "000000001101000000000"
+                                                                                                                                                       "101101110110101001011"
+                                                                                                                                                       "010001011000010000101"
+                                                                                                                                                       "010000111010100101001"
+                                                                                                                                                       "110101001110001000100"
+                                                                                                                                                       "001101100000110000100"
+                                                                                                                                                       "000000001010101001001"
+                                                                                                                                                       "111111101111010111110"
+                                                                                                                                                       "100000101000101000011"
+                                                                                                                                                       "101110100101011000001"
+                                                                                                                                                       "101110101001111100101"
+                                                                                                                                                       "101110101001101111100"
+                                                                                                                                                       "100000100010110010010"
+                                                                                                                                                       "111111101110110101110"},
+    /*  7*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 2, 1, -1, {0, 0, ""}, "01234567", -1, 0, 21, 21, 0, "ISO 18004 Annex I I.2, same (mask 010); BWIPP uses mask 000", "111111100101101111111"
+                                                                                                                                                                  "100000100111101000001"
+                                                                                                                                                                  "101110101000001011101"
+                                                                                                                                                                  "101110101100001011101"
+                                                                                                                                                                  "101110101011101011101"
+                                                                                                                                                                  "100000101000101000001"
+                                                                                                                                                                  "111111101010101111111"
+                                                                                                                                                                  "000000001001100000000"
+                                                                                                                                                                  "101111100100101111100"
+                                                                                                                                                                  "000101011010100101100"
+                                                                                                                                                                  "001000110101010011111"
+                                                                                                                                                                  "000010000100000111100"
+                                                                                                                                                                  "000111111001010010000"
+                                                                                                                                                                  "000000001011111001100"
+                                                                                                                                                                  "111111100110101100000"
+                                                                                                                                                                  "100000101011111000101"
+                                                                                                                                                                  "101110101000100101100"
+                                                                                                                                                                  "101110101100100100000"
+                                                                                                                                                                  "101110101011010010100"
+                                                                                                                                                                  "100000100000000110110"
+                                                                                                                                                                  "111111101111010010100"},
+    /*  8*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 2, 1, 1 << 8, {0, 0, ""}, "01234567", -1, 0, 21, 21, 1, "ISO 18004 Annex I Figure I.2, explicit mask 000, same as BWIPP", "111111100011101111111"
+                                                                                                                                                                         "100000101110001000001"
+                                                                                                                                                                         "101110100110001011101"
+                                                                                                                                                                         "101110100101101011101"
+                                                                                                                                                                         "101110101101101011101"
+                                                                                                                                                                         "100000100001001000001"
+                                                                                                                                                                         "111111101010101111111"
+                                                                                                                                                                         "000000000000000000000"
+                                                                                                                                                                         "101010100010100010010"
+                                                                                                                                                                         "110100001011010100010"
+                                                                                                                                                                         "000110111011011101110"
+                                                                                                                                                                         "110011010101110110010"
+                                                                                                                                                                         "001001110111011100001"
+                                                                                                                                                                         "000000001010001000010"
+                                                                                                                                                                         "111111100000100010001"
+                                                                                                                                                                         "100000100010001001011"
+                                                                                                                                                                         "101110101110101011101"
+                                                                                                                                                                         "101110100101010101110"
+                                                                                                                                                                         "101110101101011100101"
+                                                                                                                                                                         "100000100001110111000"
+                                                                                                                                                                         "111111101001011100101"},
+    /*  9*/ {BARCODE_QRCODE, GS1_MODE, -1, 1, -1, -1, {0, 0, ""}, "[01]09501101530003[8200]http://example.com", -1, 0, 25, 25, 0, "GS1 General Specifications 20.0 Figure 5.1-7 (note pre-21.0.1) **NOT SAME** figure uses Byte encodation only; BWIPP uses mask 001", "1111111001101101001111111"
+                                                                                                                                                                                                                                                                       "1000001010010101001000001"
+                                                                                                                                                                                                                                                                       "1011101011111010101011101"
+                                                                                                                                                                                                                                                                       "1011101001100000101011101"
+                                                                                                                                                                                                                                                                       "1011101010010011101011101"
+                                                                                                                                                                                                                                                                       "1000001011001011101000001"
+                                                                                                                                                                                                                                                                       "1111111010101010101111111"
+                                                                                                                                                                                                                                                                       "0000000011000111100000000"
+                                                                                                                                                                                                                                                                       "1101001100100010001110110"
+                                                                                                                                                                                                                                                                       "0100110000101101111100111"
+                                                                                                                                                                                                                                                                       "0011001001100011101111010"
+                                                                                                                                                                                                                                                                       "0000100110010101000111101"
+                                                                                                                                                                                                                                                                       "1110001000010010100010100"
+                                                                                                                                                                                                                                                                       "0110010101110101100010110"
+                                                                                                                                                                                                                                                                       "1011001100010101011110011"
+                                                                                                                                                                                                                                                                       "0100110011000110001010110"
+                                                                                                                                                                                                                                                                       "1111101100100000111110101"
+                                                                                                                                                                                                                                                                       "0000000010011011100011010"
+                                                                                                                                                                                                                                                                       "1111111010000111101010011"
+                                                                                                                                                                                                                                                                       "1000001000010111100010110"
+                                                                                                                                                                                                                                                                       "1011101001001001111110011"
+                                                                                                                                                                                                                                                                       "1011101010100100100000000"
+                                                                                                                                                                                                                                                                       "1011101000000010001010001"
+                                                                                                                                                                                                                                                                       "1000001010110101100111010"
+                                                                                                                                                                                                                                                                       "1111111011101100010010111"},
+    /* 10*/ {BARCODE_QRCODE, GS1_MODE, -1, 1, -1, 2 << 8, {0, 0, ""}, "[01]09501101530003[8200]http://example.com", -1, 0, 25, 25, 1, "GS1 General Specifications 20.0 Figure 5.1-7 (note pre-21.0.1), explicit mask 001, same as BWIPP", "1111111010111000001111111"
+                                                                                                                                                                                                                                          "1000001011100100101000001"
+                                                                                                                                                                                                                                          "1011101000111101101011101"
+                                                                                                                                                                                                                                          "1011101000110101101011101"
+                                                                                                                                                                                                                                          "1011101011100010001011101"
+                                                                                                                                                                                                                                          "1000001010001100101000001"
+                                                                                                                                                                                                                                          "1111111010101010101111111"
+                                                                                                                                                                                                                                          "0000000010110110000000000"
+                                                                                                                                                                                                                                          "1110011011100101011110011"
+                                                                                                                                                                                                                                          "0001100101111000101001101"
+                                                                                                                                                                                                                                          "0010111000010010011110100"
+                                                                                                                                                                                                                                          "0111100001010010000000101"
+                                                                                                                                                                                                                                          "1011011101000111110111110"
+                                                                                                                                                                                                                                          "0111100100000100010011000"
+                                                                                                                                                                                                                                          "1100001011010010011001011"
+                                                                                                                                                                                                                                          "0001100110010011011111100"
+                                                                                                                                                                                                                                          "1110011101010001111111011"
+                                                                                                                                                                                                                                          "0000000011011100100010010"
+                                                                                                                                                                                                                                          "1111111001010010101011001"
+                                                                                                                                                                                                                                          "1000001011100110100011000"
+                                                                                                                                                                                                                                          "1011101000001110111111011"
+                                                                                                                                                                                                                                          "1011101001110001110101010"
+                                                                                                                                                                                                                                          "1011101011110011111011111"
+                                                                                                                                                                                                                                          "1000001011110010100000010"
+                                                                                                                                                                                                                                          "1111111010111001000111101"},
+    /* 11*/ {BARCODE_QRCODE, GS1_MODE, -1, 1, -1, -1, {0, 0, ""}, "[01]09501101530003[10]640311[21]20FOOPC20", -1, 0, 25, 25, 0, "GS1 General Specifications 22.0 Figure 5.1-7 (note changed 21.0.1) **NOT SAME** figure uses Byte encodation only; BWIPP uses mask 101", "1111111011101111001111111"
+                                                                                                                                                                                                                                                                          "1000001011100111001000001"
+                                                                                                                                                                                                                                                                          "1011101010110011101011101"
+                                                                                                                                                                                                                                                                          "1011101011010000001011101"
+                                                                                                                                                                                                                                                                          "1011101000000001101011101"
+                                                                                                                                                                                                                                                                          "1000001010011101001000001"
+                                                                                                                                                                                                                                                                          "1111111010101010101111111"
+                                                                                                                                                                                                                                                                          "0000000001001001100000000"
+                                                                                                                                                                                                                                                                          "1100111000010100000101111"
+                                                                                                                                                                                                                                                                          "1000100011101110001111100"
+                                                                                                                                                                                                                                                                          "1111101000011100000000101"
+                                                                                                                                                                                                                                                                          "1000010000110100010011011"
+                                                                                                                                                                                                                                                                          "1100111110101100110100000"
+                                                                                                                                                                                                                                                                          "1011000011000100011101001"
+                                                                                                                                                                                                                                                                          "0001111001000001101101010"
+                                                                                                                                                                                                                                                                          "0000010100101001110110010"
+                                                                                                                                                                                                                                                                          "1100001111110110111110101"
+                                                                                                                                                                                                                                                                          "0000000011101010100010000"
+                                                                                                                                                                                                                                                                          "1111111001111111101011000"
+                                                                                                                                                                                                                                                                          "1000001011110100100010110"
+                                                                                                                                                                                                                                                                          "1011101010001101111110101"
+                                                                                                                                                                                                                                                                          "1011101001100110100111011"
+                                                                                                                                                                                                                                                                          "1011101001100001010101110"
+                                                                                                                                                                                                                                                                          "1000001010001010110001100"
+                                                                                                                                                                                                                                                                          "1111111010110110111110011"},
+    /* 12*/ {BARCODE_QRCODE, GS1_MODE, -1, 1, -1, 6 << 8, {0, 0, ""}, "[01]09501101530003[10]640311[21]20FOOPC20", -1, 0, 25, 25, 1, "GS1 General Specifications 22.0 Figure 5.1-7 (note changed 21.0.1) **NOT SAME** figure uses Byte encodation only, explicit mask 101, same as BWIPP", "1111111000011110101111111"
+                                                                                                                                                                                                                                                                                           "1000001001100001001000001"
+                                                                                                                                                                                                                                                                                           "1011101000001011001011101"
+                                                                                                                                                                                                                                                                                           "1011101010001011001011101"
+                                                                                                                                                                                                                                                                                           "1011101011000110101011101"
+                                                                                                                                                                                                                                                                                           "1000001000011011001000001"
+                                                                                                                                                                                                                                                                                           "1111111010101010101111111"
+                                                                                                                                                                                                                                                                                           "0000000000110000000000000"
+                                                                                                                                                                                                                                                                                           "1100011101010011000011000"
+                                                                                                                                                                                                                                                                                           "1100000111001010101011000"
+                                                                                                                                                                                                                                                                                           "0111011000100100111000010"
+                                                                                                                                                                                                                                                                                           "0001100001001101101010100"
+                                                                                                                                                                                                                                                                                           "1101001111011101000101110"
+                                                                                                                                                                                                                                                                                           "1101000101000010011011001"
+                                                                                                                                                                                                                                                                                           "1001001001111001010101101"
+                                                                                                                                                                                                                                                                                           "1011000111110010101101001"
+                                                                                                                                                                                                                                                                                           "1011001000110001111111101"
+                                                                                                                                                                                                                                                                                           "0000000011101100100010000"
+                                                                                                                                                                                                                                                                                           "1111111011110001101011001"
+                                                                                                                                                                                                                                                                                           "1000001010001101100011001"
+                                                                                                                                                                                                                                                                                           "1011101001001010111111101"
+                                                                                                                                                                                                                                                                                           "1011101001000010000011111"
+                                                                                                                                                                                                                                                                                           "1011101001011001101101001"
+                                                                                                                                                                                                                                                                                           "1000001011110011001000011"
+                                                                                                                                                                                                                                                                                           "1111111011000111001111101"},
+    /* 13*/ {BARCODE_QRCODE, GS1_MODE, -1, 2, -1, -1, {0, 0, ""}, "[01]00857674002010[8200]http://www.gs1.org/", -1, 0, 29, 29, 0, "GS1 General Specifications 22.0 Figure 5.7.3-1, same (mask 011); BWIPP uses mask 101", "11111110100101110101001111111"
+                                                                                                                                                                                                                           "10000010111101001000001000001"
+                                                                                                                                                                                                                           "10111010010000001110001011101"
+                                                                                                                                                                                                                           "10111010101110110010101011101"
+                                                                                                                                                                                                                           "10111010001010101011001011101"
+                                                                                                                                                                                                                           "10000010011111011001101000001"
+                                                                                                                                                                                                                           "11111110101010101010101111111"
+                                                                                                                                                                                                                           "00000000110110011010100000000"
+                                                                                                                                                                                                                           "10110111001001010000101001011"
+                                                                                                                                                                                                                           "00100000101101110111011001111"
+                                                                                                                                                                                                                           "11000110001011001101000011010"
+                                                                                                                                                                                                                           "11010101110110001010010000111"
+                                                                                                                                                                                                                           "11100111011100110101111011100"
+                                                                                                                                                                                                                           "01001000100100101111101001110"
+                                                                                                                                                                                                                           "10001011100111011100101111101"
+                                                                                                                                                                                                                           "01000001011110101001001001011"
+                                                                                                                                                                                                                           "10010010010100111011001000101"
+                                                                                                                                                                                                                           "00000101101000101110001011001"
+                                                                                                                                                                                                                           "10001111110011111111110010010"
+                                                                                                                                                                                                                           "00111100001011100011110101000"
+                                                                                                                                                                                                                           "01001110111001101000111111001"
+                                                                                                                                                                                                                           "00000000100000011001100010100"
+                                                                                                                                                                                                                           "11111110111110110001101011110"
+                                                                                                                                                                                                                           "10000010110111110010100011001"
+                                                                                                                                                                                                                           "10111010010010000110111111010"
+                                                                                                                                                                                                                           "10111010100111000011111111110"
+                                                                                                                                                                                                                           "10111010101000101001111001001"
+                                                                                                                                                                                                                           "10000010010111010001110010100"
+                                                                                                                                                                                                                           "11111110101111111011110100110"},
+    /* 14*/ {BARCODE_QRCODE, GS1_MODE, -1, 2, -1, 6 << 8, {0, 0, ""}, "[01]00857674002010[8200]http://www.gs1.org/", -1, 0, 29, 29, 1, "GS1 General Specifications 22.0 Figure 5.7.3-1, explicit mask 101, same as BWIPP", "11111110001000011000101111111"
+                                                                                                                                                                                                                           "10000010111011101110101000001"
+                                                                                                                                                                                                                           "10111010101011010101001011101"
+                                                                                                                                                                                                                           "10111010110110001010001011101"
+                                                                                                                                                                                                                           "10111010011100011101101011101"
+                                                                                                                                                                                                                           "10000010010100010010101000001"
+                                                                                                                                                                                                                           "11111110101010101010101111111"
+                                                                                                                                                                                                                           "00000000110000111100000000000"
+                                                                                                                                                                                                                           "10000010110010001011111001110"
+                                                                                                                                                                                                                           "00011000010101001111100001000"
+                                                                                                                                                                                                                           "01110010111101111011110101100"
+                                                                                                                                                                                                                           "00011100111101000001011011110"
+                                                                                                                                                                                                                           "10001010110001011000010110001"
+                                                                                                                                                                                                                           "11101100000010001001001111010"
+                                                                                                                                                                                                                           "01010010111100000111110100110"
+                                                                                                                                                                                                                           "01111001100110010001110001100"
+                                                                                                                                                                                                                           "00100110100010001101111110011"
+                                                                                                                                                                                                                           "11001100100011100101000000000"
+                                                                                                                                                                                                                           "11100010011110010010011111111"
+                                                                                                                                                                                                                           "10011000101101000101010011100"
+                                                                                                                                                                                                                           "10010111100010110011111110010"
+                                                                                                                                                                                                                           "00000000111000100001100010011"
+                                                                                                                                                                                                                           "11111110001000000111101011000"
+                                                                                                                                                                                                                           "10000010011100111001100010000"
+                                                                                                                                                                                                                           "10111010011111101011111110111"
+                                                                                                                                                                                                                           "10111010000001100101011001010"
+                                                                                                                                                                                                                           "10111010010011110010100010010"
+                                                                                                                                                                                                                           "10000010001111101001001010011"
+                                                                                                                                                                                                                           "11111110111001001101000010000"},
+    /* 15*/ {BARCODE_HIBC_QR, -1, 0, 2, -1, -1, {0, 0, ""}, "H123ABC01234567890", -1, 0, 21, 21, 1, "ANSI/HIBC 2.6 - 2016 Figure C5 same (mask 001)", "111111101010001111111"
+                                                                                                                                                      "100000100100101000001"
+                                                                                                                                                      "101110101011001011101"
+                                                                                                                                                      "101110100010101011101"
+                                                                                                                                                      "101110100001101011101"
+                                                                                                                                                      "100000101110001000001"
+                                                                                                                                                      "111111101010101111111"
+                                                                                                                                                      "000000000110100000000"
+                                                                                                                                                      "101000110001000100101"
+                                                                                                                                                      "000110001111001000010"
+                                                                                                                                                      "000101100101100111110"
+                                                                                                                                                      "011100001100001101010"
+                                                                                                                                                      "000101101111110110111"
+                                                                                                                                                      "000000001011000001111"
+                                                                                                                                                      "111111101111110111001"
+                                                                                                                                                      "100000100101111000001"
+                                                                                                                                                      "101110100010110101010"
+                                                                                                                                                      "101110100111010101000"
+                                                                                                                                                      "101110101101011001111"
+                                                                                                                                                      "100000100100101111001"
+                                                                                                                                                      "111111101111011001111"},
+    /* 16*/ {BARCODE_HIBC_QR, -1, 0, 2, -1, -1, {0, 0, ""}, "/EU720060FF0/O523201", -1, 0, 25, 25, 0, "HIBC/PAS Section 2.2 2nd Purchase Order **NOT SAME** uses mask 100 instead of 011; BWIPP uses mask 011", "1111111011011110101111111"
+                                                                                                                                                                                                                "1000001001001111001000001"
+                                                                                                                                                                                                                "1011101001010010001011101"
+                                                                                                                                                                                                                "1011101010000000101011101"
+                                                                                                                                                                                                                "1011101010011000001011101"
+                                                                                                                                                                                                                "1000001010010000001000001"
+                                                                                                                                                                                                                "1111111010101010101111111"
+                                                                                                                                                                                                                "0000000010101101100000000"
+                                                                                                                                                                                                                "1000101111010100011111001"
+                                                                                                                                                                                                                "1001110011101110100100100"
+                                                                                                                                                                                                                "1010111101000001001001110"
+                                                                                                                                                                                                                "0011010010110010111000100"
+                                                                                                                                                                                                                "1100011110000110101110011"
+                                                                                                                                                                                                                "1000100000101000011011110"
+                                                                                                                                                                                                                "0011111100111111101010010"
+                                                                                                                                                                                                                "0001100110010101011100101"
+                                                                                                                                                                                                                "1111101011001100111110001"
+                                                                                                                                                                                                                "0000000011000111100010010"
+                                                                                                                                                                                                                "1111111010000000101011100"
+                                                                                                                                                                                                                "1000001001101011100011101"
+                                                                                                                                                                                                                "1011101011110111111110000"
+                                                                                                                                                                                                                "1011101000101000000010001"
+                                                                                                                                                                                                                "1011101000111111110100110"
+                                                                                                                                                                                                                "1000001000010100100011111"
+                                                                                                                                                                                                                "1111111010101101111000001"},
+    /* 17*/ {BARCODE_HIBC_QR, -1, 0, 2, -1, 4 << 8, {0, 0, ""}, "/EU720060FF0/O523201", -1, 0, 25, 25, 1, "HIBC/PAS Section 2.2 2nd Purchase Order same, explicit mask 011", "1111111010011001101111111"
+                                                                                                                                                                             "1000001011010011001000001"
+                                                                                                                                                                             "1011101000000111001011101"
+                                                                                                                                                                             "1011101010111000001011101"
+                                                                                                                                                                             "1011101000000100001011101"
+                                                                                                                                                                             "1000001000111010101000001"
+                                                                                                                                                                             "1111111010101010101111111"
+                                                                                                                                                                             "0000000011001110000000000"
+                                                                                                                                                                             "1011011101111110101001011"
+                                                                                                                                                                             "1110110100101001100011100"
+                                                                                                                                                                             "1001011110100010101010010"
+                                                                                                                                                                             "0110000111100111101101110"
+                                                                                                                                                                             "1011011001000001101001011"
+                                                                                                                                                                             "0100110100110100000111101"
+                                                                                                                                                                             "0110101001101010111111000"
+                                                                                                                                                                             "1001010110101101100100010"
+                                                                                                                                                                             "0011111111010000111110010"
+                                                                                                                                                                             "0000000011101101100010111"
+                                                                                                                                                                             "1111111010111000101011011"
+                                                                                                                                                                             "1000001010001000100010001"
+                                                                                                                                                                             "1011101001011101111110101"
+                                                                                                                                                                             "1011101011101111000101001"
+                                                                                                                                                                             "1011101011011100010111010"
+                                                                                                                                                                             "1000001001000001110110101"
+                                                                                                                                                                             "1111111011101010111111001"},
+    /* 18*/ {BARCODE_HIBC_QR, -1, 0, 2, -1, -1, {0, 0, ""}, "/KN12345", -1, 0, 21, 21, 1, "HIBC/PAS Section 2.2 Asset Tag **NOT SAME** uses mask 000 instead of 100", "111111100000101111111"
+                                                                                                                                                                      "100000101010101000001"
+                                                                                                                                                                      "101110100011001011101"
+                                                                                                                                                                      "101110100001101011101"
+                                                                                                                                                                      "101110101110101011101"
+                                                                                                                                                                      "100000100010101000001"
+                                                                                                                                                                      "111111101010101111111"
+                                                                                                                                                                      "000000000111100000000"
+                                                                                                                                                                      "101010100011000010010"
+                                                                                                                                                                      "111010010000001100001"
+                                                                                                                                                                      "111010101110100011001"
+                                                                                                                                                                      "011000011010001011001"
+                                                                                                                                                                      "100001110010101001001"
+                                                                                                                                                                      "000000001001010110001"
+                                                                                                                                                                      "111111100001011100011"
+                                                                                                                                                                      "100000100101110101000"
+                                                                                                                                                                      "101110101001011000111"
+                                                                                                                                                                      "101110100010001001110"
+                                                                                                                                                                      "101110101100100111001"
+                                                                                                                                                                      "100000100100001100111"
+                                                                                                                                                                      "111111101000101110101"},
+    /* 19*/ {BARCODE_HIBC_QR, -1, 0, 2, -1, 5 << 8, {0, 0, ""}, "/KN12345", -1, 0, 21, 21, 1, "HIBC/PAS Section 2.2 Asset Tag, same, explicit mask 100", "111111101010101111111"
+                                                                                                                                                         "100000100111001000001"
+                                                                                                                                                         "101110100110101011101"
+                                                                                                                                                         "101110101011101011101"
+                                                                                                                                                         "101110101100101011101"
+                                                                                                                                                         "100000101111001000001"
+                                                                                                                                                         "111111101010101111111"
+                                                                                                                                                         "000000001101100000000"
+                                                                                                                                                         "100010111001011111001"
+                                                                                                                                                         "010111011101100001100"
+                                                                                                                                                         "010111100011001110100"
+                                                                                                                                                         "001010001000011001011"
+                                                                                                                                                         "110011100000111011011"
+                                                                                                                                                         "000000001100111011100"
+                                                                                                                                                         "111111101100110001110"
+                                                                                                                                                         "100000100111100111010"
+                                                                                                                                                         "101110101011001010101"
+                                                                                                                                                         "101110100111100100011"
+                                                                                                                                                         "101110100001001010100"
+                                                                                                                                                         "100000100110011110101"
+                                                                                                                                                         "111111101010111100111"},
+    /* 20*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 1, -1, -1, {0, 0, ""}, "12345678901234567890123456789012345678901", -1, 0, 21, 21, 1, "Max capacity ECC 1 Version 1 41 numbers", "111111101001001111111"
+                                                                                                                                                                                "100000101100101000001"
+                                                                                                                                                                                "101110101011101011101"
+                                                                                                                                                                                "101110101011001011101"
+                                                                                                                                                                                "101110100001001011101"
+                                                                                                                                                                                "100000101001101000001"
+                                                                                                                                                                                "111111101010101111111"
+                                                                                                                                                                                "000000000110100000000"
+                                                                                                                                                                                "110011100010000101111"
+                                                                                                                                                                                "010101001011010101100"
+                                                                                                                                                                                "100100110110011100101"
+                                                                                                                                                                                "011100001001001101011"
+                                                                                                                                                                                "011110111010011010001"
+                                                                                                                                                                                "000000001000001100111"
+                                                                                                                                                                                "111111100110110100110"
+                                                                                                                                                                                "100000101110000011001"
+                                                                                                                                                                                "101110101111000101110"
+                                                                                                                                                                                "101110100101010101111"
+                                                                                                                                                                                "101110100100001110000"
+                                                                                                                                                                                "100000101000101001010"
+                                                                                                                                                                                "111111101010110000111"},
+    /* 21*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 2, -1, -1, {0, 0, ""}, "12345678901234567890123456789012345678901", -1, 0, 25, 25, 1, "ECC 2 auto-sets version 2", "1111111011001110101111111"
+                                                                                                                                                                  "1000001001000000001000001"
+                                                                                                                                                                  "1011101011001111101011101"
+                                                                                                                                                                  "1011101001100000101011101"
+                                                                                                                                                                  "1011101001101011001011101"
+                                                                                                                                                                  "1000001010111110101000001"
+                                                                                                                                                                  "1111111010101010101111111"
+                                                                                                                                                                  "0000000001111100000000000"
+                                                                                                                                                                  "1010001100000101000100101"
+                                                                                                                                                                  "0111010101111001011000001"
+                                                                                                                                                                  "0010011101000111110010011"
+                                                                                                                                                                  "1001010100011011001100011"
+                                                                                                                                                                  "1000101101100111010110101"
+                                                                                                                                                                  "0001010000100111101011011"
+                                                                                                                                                                  "1111101100010001011000110"
+                                                                                                                                                                  "0000100001000101011010011"
+                                                                                                                                                                  "1101001101011100111111101"
+                                                                                                                                                                  "0000000011001001100010000"
+                                                                                                                                                                  "1111111010101110101010001"
+                                                                                                                                                                  "1000001000111011100010001"
+                                                                                                                                                                  "1011101000100111111110110"
+                                                                                                                                                                  "1011101001100110010101000"
+                                                                                                                                                                  "1011101011110001000100111"
+                                                                                                                                                                  "1000001000000100111010110"
+                                                                                                                                                                  "1111111010011100001100111"},
+    /* 22*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 4, 10, -1, {0, 0, ""}, "点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点", -1, ZINT_WARN_NONCOMPLIANT, 57, 57, 1, "Max capacity ECC 4 Version 10 74 kanji", "111111100111100000011001000011111100010010011011001111111"
+                                                                                                                                                                                                                                                                                                               "100000100011100101110000101000101001101111000001001000001"
+                                                                                                                                                                                                                                                                                                               "101110101001011100010001111110111100101001100011001011101"
+                                                                                                                                                                                                                                                                                                               "101110101101000010101100100011001110101001000101001011101"
+                                                                                                                                                                                                                                                                                                               "101110100011100100011000101111100110110000011101001011101"
+                                                                                                                                                                                                                                                                                                               "100000100000100111011111101000111101111100111010001000001"
+                                                                                                                                                                                                                                                                                                               "111111101010101010101010101010101010101010101010101111111"
+                                                                                                                                                                                                                                                                                                               "000000000001110101110110101000110111010111010111100000000"
+                                                                                                                                                                                                                                                                                                               "000110110011100011001111111111111010001100000011100001100"
+                                                                                                                                                                                                                                                                                                               "110110011010111001101110111010101010101101010001000100110"
+                                                                                                                                                                                                                                                                                                               "011100111000110100011101010110011100010010110011010010011"
+                                                                                                                                                                                                                                                                                                               "001011001011010100000011001101100111010100111110011100001"
+                                                                                                                                                                                                                                                                                                               "001000101011000101110011110001101001000001010100101001001"
+                                                                                                                                                                                                                                                                                                               "111011000111101101100101000100000000000101001101010101011"
+                                                                                                                                                                                                                                                                                                               "111010100110100110011101000100111101100100101001001101001"
+                                                                                                                                                                                                                                                                                                               "111100001100101010011101001111110010010101110011110011100"
+                                                                                                                                                                                                                                                                                                               "011111100011001001000011000011111111000101000010011011011"
+                                                                                                                                                                                                                                                                                                               "000011010001111101111110111000000011111100111100001001010"
+                                                                                                                                                                                                                                                                                                               "001110101000100011000110100101011010101100000101101010000"
+                                                                                                                                                                                                                                                                                                               "100111010111110011011011011110011111001010100111000111110"
+                                                                                                                                                                                                                                                                                                               "100110101011010110111100011100010100011011001001110110001"
+                                                                                                                                                                                                                                                                                                               "011110000111001010110011100100110100110101011110010101011"
+                                                                                                                                                                                                                                                                                                               "000011100101101111100111000111010100101111000110110111000"
+                                                                                                                                                                                                                                                                                                               "110111000101010010100001110110100110010110011000010000001"
+                                                                                                                                                                                                                                                                                                               "101100111110110001110100100101101001010001111000000010111"
+                                                                                                                                                                                                                                                                                                               "000100000100000110011110000110011010001111000100000110000"
+                                                                                                                                                                                                                                                                                                               "010011111011001010111100001111101011001011011101111111010"
+                                                                                                                                                                                                                                                                                                               "011010001100111001110100101000100011001001000000100010110"
+                                                                                                                                                                                                                                                                                                               "100110101001110001000100111010101011010000011010101010000"
+                                                                                                                                                                                                                                                                                                               "100010001100111000011110011000111011011100111010100011011"
+                                                                                                                                                                                                                                                                                                               "011111111001011110111100011111101100110001010000111110100"
+                                                                                                                                                                                                                                                                                                               "100110000110011111100111111011001010000010010011101011011"
+                                                                                                                                                                                                                                                                                                               "011001100001000011001010001111001010001001000011001101001"
+                                                                                                                                                                                                                                                                                                               "011111001110010111101010111001110100111101110101000111011"
+                                                                                                                                                                                                                                                                                                               "101101100100110100001111101001111001100101010010010010000"
+                                                                                                                                                                                                                                                                                                               "101111000101101101110001100111100011101101001100010101010"
+                                                                                                                                                                                                                                                                                                               "100000110000011011111010000110011100000010000001100100000"
+                                                                                                                                                                                                                                                                                                               "001011010101010110000000000110000001001010100011000111000"
+                                                                                                                                                                                                                                                                                                               "001011100110101101100100011100100100011011010000011001111"
+                                                                                                                                                                                                                                                                                                               "001010000001100111100000111010100101110010011011010010011"
+                                                                                                                                                                                                                                                                                                               "110100101110010001110000111101101111000010100010011010010"
+                                                                                                                                                                                                                                                                                                               "011011000101100001111000110110110000011000010101101110011"
+                                                                                                                                                                                                                                                                                                               "000111110011111101101110111100001001101010000100000100110"
+                                                                                                                                                                                                                                                                                                               "101100001100010000011101011011001011001101000111111100000"
+                                                                                                                                                                                                                                                                                                               "000011100110110111010011101111011101001001000010000111101"
+                                                                                                                                                                                                                                                                                                               "110000011010000010000001111100111001010000000001100101010"
+                                                                                                                                                                                                                                                                                                               "101001110100100111111111010001101010011010011010111111110"
+                                                                                                                                                                                                                                                                                                               "111110001100001100010100001011110011001110000100011110010"
+                                                                                                                                                                                                                                                                                                               "000000110011100011000011111111111000001000100011111110010"
+                                                                                                                                                                                                                                                                                                               "000000001000001101101000101000101100000110010011100011100"
+                                                                                                                                                                                                                                                                                                               "111111101001111111010001001010100110001011000011101011010"
+                                                                                                                                                                                                                                                                                                               "100000100111000101110010001000110100111101011100100011010"
+                                                                                                                                                                                                                                                                                                               "101110101111110100111111011111100001111010110100111110100"
+                                                                                                                                                                                                                                                                                                               "101110101001110011011100111111011001000011001101000111010"
+                                                                                                                                                                                                                                                                                                               "101110100110010100010000101001000010000000100000100000111"
+                                                                                                                                                                                                                                                                                                               "100000100110011101110011001101110110101010001101000011011"
+                                                                                                                                                                                                                                                                                                               "111111100010001101010110001001000001001011001001011001011"},
+    /* 23*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 4, 27, -1, {0, 0, ""}, "点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点", -1, ZINT_WARN_NONCOMPLIANT, 125, 125, 1, "Max capacity ECC 4 Version 27 385 kanji", "11111110101001001100111100100011110001010011110000001100010110100011101010111000011101101001011111001111101101101001101111111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10000010110001101110011001101111000101001011011001100110101000101010011110000000101000100101101110110000011110100110001000001"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10111010100000000100000101000101111001011001010100100100100000000101100011010001100111101010010101101101101101101101001011101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10111010001100111011000110111100100000010101010111010010101000111001000001110000001100011101100001111100110000011000001011101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10111010010000100010110110100010111111110011001000011100100111111101110110001011001001101111111101100101001101101011001011101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10000010100100110000111100010111100010101111100000011100011010001100011100110110111111101000100111001111101001111111001000001"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11111110101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101111111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00000000111011101111001100100010100010100111111111100111011010001111000110000111001000111000101100110000011110100101100000000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00111010111100111100001111100100111110110101011011110011101011111110110110010100010111101111110101001101101101101101111100111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01010001001110001010011100111101111111010010000011001110010000110110000010011011001100000110101111111100110000011111010100100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01001011010111110101110001011100000100110001011100000001111001011100111000001001001101101001101111101111101111100000101111111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01001101011110100110000011010101111011000110001011001100001100100000100101101010011111111101111101001001101001111111101001000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11101011010000001011000000010000011011101110000010110000011111101011011101111011001000100100001100110000011110100000011110101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10100100011000101010111100001001010011100101101000100110010110101111000100000000110111111101101111001101101101101101101011101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00101111000111111110001110110110101011110111111111000001011010111111010010110101001100000110100001111110110100001110101100100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10100100100111101010111001110101110111001100100010100010011001000001000111011110001101101001111111101001101111100000100001111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00100111011001010100000010011101001110110001001011110011111000000100010001011001111111001111111101001001100001011101011111000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01001001000110000001110100000101100100100000100010111010010000110001101010000100001000100100001100110100011110100001111011101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01000011110000011000110011111010110110101101000111111101110100010011100000011011110111111101100101001011101011101100101101101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11011101001001011001010101110001000010111111010000011000001110110000101100100111001100000110111001111100110100001110100000100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00101111011110000000010110100100111000010000110000110101000000110100011100010110100101101001111111101001101001100101011111111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10000000100011100111101111111010111011011000011100011001111100011110010001101011011111001111101101001111100111011101111100000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01000010110100011000111111001011101101100101001011111100100001100101111110101011001000100101010010100101011110100001101011101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10010001110100100101110011111111111110011000101101000001000101001100011010001111010111111101101101001101101101101100110101101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01000110111000011111001000100000101100101111110010001110001011010010010111111001101101100110111000111100101001101011101000100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01110001111111110101100001111010001100000010110000100011001101001101100101001111100101101001100111101101101101000101111101111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10100010000110110010001011000001011101000011100001110110110001000011110110110000111101001110101101011000100110111100000100000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00001100000110110010011101000010001100000100001010001000011011010001110010011010101000100101001010100101011101100001101011101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10101110100000110101111000101010111101000000000011011000110000000110100001100111001111011101101101101101100101101101001101101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11011000111001110111001111011011001101110101001101110101011011111001010100101010001101100110101000111110101111001010101000101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10010111001010111101100110101011001000000000101011000110101101011001100001110111000011101000111101100001001100101101001101111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11111101101011111000100001100001111101000111101010101001010100010011100011111110011101001111001101011100100101011100011100000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01001111110111111101000000101100111111001010100110110011001111111101001011101111000000101111101011100101011011100001111111101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11101000110000111010100001011011100011000000110010011000011010001011111110010111001111001000100101101111100100001101100011010"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11001010100101001110110100001100101010011111001000110110001110101110111011011111001101111010111000101001101111110010101010101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00111000101010110000101110101101100010101111100010101100111010001110000100110110000011101000101101111111001001101101100011111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11101111101111111100110011010001111111011010110000111001100011111110110011010001111100101111101100000100100111011111111110000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01111001001001110011100110110000001100111110101100001001101101010111101110100001100001011001100011101011011101100000101011101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11000011011111110000011000001011001000110001111001011000011001100000111110100101001101100101111101101101100101101100101101010"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01111000001110010011000110011001101101001011001101000000111111101101011110011001001101111110100000111101101001010011000000101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01110111000001111000011001110000101001000011111011011100011010011111001010110100000011100001101101101111001111101101111101111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10010101101010110110000000010100101100001111010100011001010010010100001001101101111101101101110100001100100100111111101101101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01010010100001110011000010000101001100111111011011100011000111000000100000101111000000111000001111101101011101101000101111101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11001100111011000101111100100101100000010000100011010010100111110001110100010101001101100101101101101111100001001101100101010"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10011011100101110010001000111011001100000010011101100010101111010001001100010011101101111111011000100101111101010101111000101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00101101101001000011101111001011010001110101111000001010111011111011011010110011000011000100101101111001001100101100100101011"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11111010100000100111000001010111111000100101001001001010011110101101011010110111011100101101010000001100100101111111101001101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01000001001110011000110000001010110111100011010010110010110101111101110101111001000001101000001111110111011100001001010111101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10100010011011000110000101000101100010100000000000110111100101000101100101110010111101100101100101001111101111001110101101010"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10101100001100010010001000111101101111000111100010000010111111000000101010001111001101011010111000111001111000110101101000101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01011111100111101101111111010110000101100010101111011111111111000001101101000110000110100101001111111101101101001100000111011"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10110001100010010001011111110000000011011010000111001010111100001010000010110110011101001101010000000010100011111111101001101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11100011100101110101110111010010010100010000010110010101100101001100011011111010001001101001101111101111001100001000101111101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01010100001001111100100100101000010011011111100010001010110010000001110001011101011100000100100101011001101001101111100100100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01100111110000010010010111100110010001001101000010000000001001110000000100100101001011111011111100111110011001100101001100001"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01111101001000111110011001000000100001010111011100000100000101101001111100010001000101100101001111100101101110101101111110011"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01110110000101110101001100110111010110000001001000010001001001011001000000110010001001001101101001101010110101111110101001001"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01000001100000101010110100110110100001101111011010111001000011110011110110101100101111101001101111101101001001101001100111111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11100011000100100100110100011011111110100111111111001101011111101100011100110010111101101101000101011101101001011111001101100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11011101101010001101000110100000110000100001100111101110011101101111000000000010110011011011111100101000011110100101101100101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10001111110101110110000011111001111110111101001100001000101111111010110101010110111101101111100111001101101100101101111111111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01101000101110101100010100110011100011001100001101010000110010001000000000011110111000111000101001110010110101111111100011100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01111010110111000101111011011001101010100111010101111111111010101110111001001111001101101010101111101101101001000001101011011"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01101000110110110001111111010010100011001100011101001000101010001100100101001000110101001000100101000101101100111111100010100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11111111110000011110001010001011111111111000011010000101011011111001011100011011010011001111111100111000011100100001111111101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10110001101000101000010011101000011111100111110010100011010001111111000011000010010100111101100111000101101011101100111111101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00100010111111100000101101110111001011101101110101000010111010011011010000110000011001100110001001110010110000001111101001000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10100000000111101111111111010111001001001000101000111010111011101011000101011100000100001001101111101101101101100001110110111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00000111100001000100111000101100010100110111001100111011111110110100010111011000000101011101000101011111100100111101001101000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01100101010110000111010100100100011000100110100110101101010110001011101011100110111010100010111100100000011011000001101101101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01100011000000011011101000011001010000100001000111110011001001111111100001100010100101011101000101000101101101101100111110001"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11010101011001001111010000101000100110110101010000010000110001110010101010100111111001100111101001101010110001101111101001100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00000110011110010110110110000001111100011010110001011111000010100010011001101111010100001001101111111101101101100100110111111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10000000100011111010001011010111010011000010011000111000000111100110010000010011000101101100100101001111100101111101001101000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01010111111100000011100101000111101011100110001100001110101001110001111011110011100111100101011010100001011110100001101101101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10100101111100111001000011001010100010000001101001111111010110001000011001011111100100111101100101001101101101101100111101101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01011110111000011000001111001001001010111100010011000110011001101010010011001000101001100111111000101100101000001011001001000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01100100011111110101001101001110101110011110110100100011010010010111100000010110001101101000101111100101101101100100110111101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10101110110000100001110011011110111111000100100111100010100100000101110010001001110001001111100101001110100001111101001100101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00001000111100100001101100111011100100010100001110000000011100110101110111010010111110100101111010101001011110100001100011110"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10110111101110110001111000011001100001001110100111001010100100010000100000000110110100111101101100110111100101101101111101001"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11011101001101100101101110111000100001110100001001111101010110110011010111000011010001100111111001101100101000001011001001000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10001111100110100010000111100000011100001100001010001110110000110001100101110110010111001001001101001101001111101100110110111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11111001010001111001100001001111010011001111001000011001010110011101100101011110001000101110100100101110100001111101001101100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01000011011111100011000000011010010111000101100000111011001101100101001001101111110110100101101010110001011110100001100010001"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11010001111100110000000001000000110001001000010001001000010111010111111111000110011101101100001101101111100101101101111101001"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11010111001011001000010101101101011100000000101010101110001001000010011100101111011100001111111000011101101100010011001000111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00111001100000111000001110111011011100110001000001101100100001001101100011110110010111110000101101101101001111101100101101000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11101111111111110100110010001111111111010101010111010001111011111101110110000001111001001111110100101110100001011111111111101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01101000111101111110100110011011100010110111001101100001110110001000001001010001111110101000101011010001011110100000100010001"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11001010111111100011111001010110101010110011011000011000010110101110011010111101000101101010101101101111100101100101101011111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01111000100110000000100111100111100011000100101100000000111110001011011011101001010100011000111001111101101100001011100011101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01101111111001100001111001011000111111000100011011011100000111111001001000111100001111111111101101101101001111111101111110101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10000101111000100001100001011111110010011111110101100001011011001101101100010101111001001111110101101110100001001111101101101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01100011110001110111000010100110010100100100011011000011000111000101000110010111001110111100001110100001011110100000000011101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11001000001011000011111100001101011110010010100010011010111000000101110101111101000101101101101101101111100101101101111101000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10000110101011110011101000000011110110000011011101001010110001111000001001110011100101100110111001111001101101101100100000111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00011100101111000101101110101010111111101110111000010010101011001111011110100011010111101001101101001101000111100101101100101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11001111000100100111100001110110110010111010101001100010011110001110011101000111010001011111110000111110111001001111101101110"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01000000101100011010010000000011011001110001010010110010101001001101110111100001010110101000001111100001000110101001000011001"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10011110100111000111100100110101111000100101100001101111111111111101000001011010110101000101100101101101101101010111111100111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10000000100100010010001001110101001001010111100011011010101111110110001100110111011101101110111001011001110101101100100000111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01000111001101101111111110101111001101110010001111110111101110000010101101110110010101101001101110100101101101100101001101100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10010101100000010010011111000001111011001111000110011010100010011110100011000110010001001101110001011110101001011110101100001"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11010010101111110111110110000010111010000000010111110101111111001001011011111010001110101000001111100101000110100001000111111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01011100111111111111100100111001101111001110100010010010100011101010010000100101010101001101100100001101101101001111111101011"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01101011111100010110010111000111101111001110000011101000000111010011100100011101010011110110111101101001101011101100100000100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01011101110110111110011001100000001101010011011100110100010011100011011100000001001101101101101111100100100101111101001101101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00011010111011110000001100010110011111100011101001110001010000101010100000101010001001000001101001011011101001000110101000001"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00000001001110101010110100100110011001101010011011010001000111101111010111010100101110111101001111100101111110101001000111111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01100010001100100000110100010010001000100010011110101101001001011010111100001010110101000111100101101101101101001111111101001"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00001100011010001100000110101000001110000111000110000110000101010100100001111010100011100110111101001001100011111101100000101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10001111110101110010100010111000101001111101001100111000111111011100100101000110110101101001100111100101000101101111011111110"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10010001100110101111010100010011010111001111101100110000110100001011010000100110101001011100101000111010111001001000101001101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "01001111100001000001011011100000110111100101010100111111100101001111110001101111010100100011001111100101101100101111000111100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10101100000010110111011110011011101101001101011100000000111110000111000101100000110101000111100101001100010101001101111101011"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10000011101010011111101011011010111111011010111010101101011011111010110101010011000010101111111101001001100010100011111110100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "00000000110110101010110010111001100011100101110011010011000010001000000010110010011101101000100110100100111101111101100011010"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11111110011101100111101101110111101011001010010101011010100110101101101001001000011001011010101001111010100001001101101011101"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10000010001001101110011110000111100011001110101001010010110110001011000100001100001100101000101110000101001100110000100011111"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10111010101110000011111001100101111110110000001101110011100111111101101110100000010101101111100101001111110101101100111111000"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10111010100101000001110101011100111010000000000110000101010011110001010010011110111010101000111100101000101010111101101100100"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10111010101000111001001000010000000000000111000110100011000101101001010000100010101101111111000001001100101101111110111111010"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "10000010010111001111010001100001010001010110110001100000111101011100000010010111101001001100101101111011011001000001101001110"
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "11111110000000010001110110000001010111011111000000111111010101110100101000110111000101101011001100000101101101101001100111111"},
+    /* 24*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 4, 40, -1, {0, 0, ""}, "点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点"
+                                                                      "点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点点",
+             -1,
+             ZINT_WARN_NONCOMPLIANT,
+             177,
+             177,
+             1,
+             "Max capacity ECC 4 Version 40 784 kanji",
+             "111111101010001111111101101110111010110111001110101000010001011011011101001110110011111011010000010101001010011110010000010110111111001001011111101000010010111111001010001111111"
+             "100000101010110001001000101111011001001100100110110000000111110101111011110001101110000111000100101111010011001111100111111001001011011011110011011111111001000010010010101000001"
+             "101110101001001101111001110010010100000000111001001011111000001001111111101010000111011010011010010001111010111001100011000011110100101110001010110001011110011011011010001011101"
+             "101110100011110010000001101101010011100111111111001101100000101100100000111110101110000010101000000010000100011001100001011010011011011001110011001011010011111101101001101011101"
+             "101110100101110010111000011011111101111011011111010111111111110110000100000111110101111110000011101011110001110011111111111111000010010111011111111011101011001011010100001011101"
+             "100000101001101111111111110110001000000111010010011110011000101101011100000010001001100011011101110000101111011110001010010001011111011001011000101000010010111111001010101000001"
+             "111111101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101111111"
+             "000000001010101000111100111110001110000001101000010000111000100000101011100111110000100011011011100100000000100010001111111011001011011011111000111111111001000010010111100000000"
+             "001110101100010001001111000111111110001110001111010001111111111011011010100101110010111111101101110110100110000111111011011011111101101010011111110001011110011011011000011100111"
+             "010000000011010000110010100101111011001000111011000000110110100100010001011011000111000100101100101110001111010001010001010110011011011001110000011011011001010000111111111001111"
+             "011001100011010111001100111001100111110000011011000101111011101100110101100100000110001111011011010010111100101001110011111011100000000110001111111011101011001011010011011110000"
+             "100001011010011111011000010011100000110011111100011101010010010001101001001000001100100011000111001100010000000101110010001011011111011001010001001000010010111111001001010001011"
+             "011100100100100100111110111101111011100110011110001111100000110001001110110101111000001100011010010000011110110001000111111011001010011011111010111111111001000010010111101010101"
+             "110001000100011100001000001010100100010011100101001000100011010010101111101001111110101011101010100010101010110100101011010011111101101010011011000000000110011111011010010011011"
+             "100001101000001001011000111001001101101001110001001001100111010000111001110100000111000010100000110010010011110111101101010001011011011001011000011011011001010000111111111001111"
+             "001000011111011110001101000110101000010010100110000010100000101000001111110101001111011010010001000110111111100001101011101110000000000110001111011011101011001011010011011110000"
+             "110001101011101010001001110101111100011110011100010000010011100110000010110100000001110011010000111111110100011111001010011011011111111001010001001000010010111111001001010001011"
+             "010101001011001100101001001100000010110010011010110001010110011010111110000100010101110001000010110011001000111111001111100101101010011011111010111111011001011000010011101011001"
+             "100011100111101001011100111011111101001010110000010101101001110001010010000100110010010011011111011100011101001010110011010011111011101011000011000000000110011111011010010011011"
+             "100101000111111110000111000000001000011100000010111011010001000000110100001101101001110010011101001000111011000101101101001110011011011001011000011011011001010000111111101011111"
+             "011111111011000001101111101011101011110100111010000010100111100111010110100111101011010101100001000111000100111000110011010011010001000110001111011011101011001011010011011110000"
+             "100110011001110000000000100111100010001010111110111000010011001010001100011011101000100001110000001111000100100111000010011010111111111001010001001011011011110011101101010001111"
+             "111001100111011110111110001100010010001110000000111110011100000110000010010110100110111101000111101010001000100000100111100101101000010010111010111111011001011000010011001011001"
+             "011011000111000100000101010101010111000101101000001111001100001001101001101110101110010001000011000000011110110100100011011010011011101011000011000000000110011111011010011101011"
+             "010111110111010111010011100001000000001101101000010000000001001000101101000110011010000001100111010001011110010001100100111111101011011011011000011011011001010000111111101011111"
+             "011010011000101101000111011111100011111101010110100111110111100100101111101111001100010000100101100100001100110000001011001011010001000110001111010100101110001011011011011110010"
+             "010100110110001011100001100100111001101101010100111101000011011000100010110010011110111011101111000001010001001100001000011010111111111001011001001011011011110011101100110001111"
+             "011100011110011110110001100011101001110010011100101001100001100011101101011001001010011110010010010101111011100001011111111101001000010010111111111111011001011000010011011011001"
+             "110011111101100110111010010011111001010000001100001001111111101000010000001110011111111110100000100100001100100111111011010011010011101101001111100000000110011111011010111111011"
+             "111010001010001001111001001110001111100110011111101000111000101000111010101101001101100010110010010001011110001010001100101110001011011011001000111011011011110001000111100011101"
+             "101010101010000100101010101110101010000011111111110101111010111100101001101110000110101010111011010101001100011010101011001011010001011110011010110100101110001011011011101010010"
+             "011110001010001011000110010110001111001001111101101011101000100011011111001000100111100010111000011110001101101110001000011011011111111001011000101011011011110011101100100011111"
+             "010111111001110000101101100111111111011100101100001001111111111110100110111010010110111111110111101110111100110111111111010001111000010010101111111111011001011000010011111111001"
+             "011101000011010100010000000101000001000000001101010101111011101110111100001100010100000010110011101100111100100110110011001010010011101101011011011010010011011111111001111101010"
+             "110110101000001010101010001100010111100011100001011001010010010001100110100110010101100001001010110111000011010000010010101110001011010011111000011011011011110001000110001011101"
+             "100001001000010111011100111000000010111011101001100100001000111110000111000101100011110011011010000011001010110111011011011011010001011110010111010100101110001011011011111110010"
+             "001000100011000110000011110010101101011010101101010111101011011100011010000101101001011000111101011000011101100011011000000111111111011011001010001011011011110011101101000011111"
+             "101010011001011110001001111001101110101110011110110100011011101111101001000000101110010101111101101011110110100101101111011000011000010010110111110111101101001010011011011010011"
+             "001001100010001010001010100010111111111110011010011010101001110011001110000000011001011101101011101101000000010011100001001010010111101101011011011010010011011111111001111101010"
+             "010111011111110111011101100010010000110110000011110000000010110110000001100000101000001010100101111001101001001111011010110111001011010011111000011011011011110001000110001011101"
+             "010011111110100010001111101011000110111111111000110101011111011010001100010111010011111010010101011100000101010110001011011000110000111110011011110100101110001011011011111110010"
+             "110000001100100101000100010110110001001000101010001111111110010100100000000001010010010001001111010001001100001110001000011111011111011011001010001011010011111101101011000011011"
+             "001011110111001011011111111010111101111010000100100110101110110000010011110110001100110100111010000111101111100010110111011000011110010011010111110111101101001010011011011010011"
+             "101000000011001000011100100011111000010111000011000111010010100010110000100100101111110001011011011001000100010000100001011011110011101101011011011010010011011111111001111101010"
+             "011001101011010001100101011011101011010000100101010110111011000100110101111010111101100010000100101110001011000100100011101011001101010011110101011011011011110001000110001011101"
+             "101001010110110000011010010000110110001011100100010001101111111001000111000101110111010100010000101000100110010010111011011001010010111110011011110001011110011011011001111111010"
+             "011000101101010111000100100110010110010110101101110011011101110011100001001101110010100001011001000100101100110001100000011111011111011011101010001011010011111101101011000011011"
+             "010011000001101111010000000000001111101011100100001011110111100010011110111100001100111001011000110000000010110100000111010001011000010011010111110111101101001010011011011010011"
+             "100110100000111001000111110111010000111111101100101010101111101010001110101101110011111000101001011111110000010101101000001010011011001001011011011010010011011111111001010001010"
+             "001011010001011000101001100000101001001000010000000000101111000001100111101010000111010000000111111100101110110010001011111011001011010011100101011111111001000010010111001010101"
+             "100110111011100111010001111111010110110001100011011110100011010010010010011110101011011001001111010001010101110000000011011001010010101110011011110001011110011011011001011111010"
+             "110100011101010000011101101010000011100001100011010001100101100001010101010000010110011010111100101111111011101110011000010111111011011011101010001011010011111101101010100011011"
+             "101000101111001111010000001010011101001101011000010111011010111101111000101111100000111101111111100000011111101100000111101000000110010111011111110111101101001010011011011110011"
+             "110011010010001111111100001100100010110010101111001110101011111101011111001110110010111111010000010101001010011110000000010011011011001001011011001000010010111111001001110001011"
+             "011111111010110001001001001011010000001110100110010110101100110010011101110001101111100111000100101111010010101000100111111011001011011011100101011111111001000010010110001010101"
+             "110100001001001101111000010010110101100011111011001010000110101011111011101010000111111100011010010001111010111011101011000001110000101110011011110001011110011011011001111111010"
+             "110011111011110010000000001011111011100010111111001101011111101110000000111110101111111110101000000010000101111111111001011110011111011001101111101011010011111101101011111111011"
+             "001010001101110010111000111110001101011101011010010000001000110100100110000111110101100010000011101011110000010010001111111001100010010111011000111011101011001011010010100010000"
+             "110110101001101111111110110110101001100011010001011001011010101100011010000010001001101011011101110000101111111010101010010011011011011001011010101000010010111111001001101011011"
+             "011010001010101000111101111010001110100001101000010000011000100001001101100111110001100011011011100100000000000110001111111010101001011011111000111111111001000010010111100010101"
+             "111011111100010001001111100111111110101110001110010101001111101000011000100101110010111111101101110110100111100011111011011011011111101010011111110001011110011011011000111111010"
+             "010000011011010000110010100000111010001100111111100001000001010010010011011011000110001110101100101110001111010101100001010111011001011001110000011011011001010000111111011001111"
+             "011001101011010111001101111111001111010100011000100010111101001011110101100100000111000101011011010010111100101101111011111001100010000110001111111011101011001011010010011110000"
+             "100001001010011111011001010011100001110101111111100000100100011100001101001000001100011101000111001100010001000110111010001011011101011001010011001000010010111111001000010001011"
+             "011111100100100100111111111011110010100010011111011110011111111101001110100101111001011010011010010000011110010100110111111101001010011011111101011111111001000010010111101010101"
+             "110001001100011100001000001101010101110001100010110010111000000110101001110001111110101101101010100010101011110010110011010011111011101010011011000000000110011111000011010011011"
+             "100000101000001001011000011101001101001001110001001111110011100110111111100100000111011010100000110010010011110001110101010111011001011001010000011011011001010000111111011001111"
+             "001000000111011110001101100110101000010100100000101010111001110100001011110101001110011010010001000110111111100000000011101000000010000110001111111011101011001011001010011110000"
+             "110011101011101010001000010011011100111100011110011100010110000010000000101100000000100111010000111111110101011101101010011011011011111001010011001000010010111111010001010001011"
+             "010100001011001100101001001110001010010110011100001101000000110010111010011100010100011011000010110011001000111111110111100101101000011011111010111111011001011000010011001011001"
+             "100000100111101001011101011001011101101000110001100111100001111001010100000100110010100011011111011100011101001111101011011011111011110011011011011000000110011111011010110011011"
+             "100100000111111110000111100011110001111110000100010101000110011110110100010101101001000100011101001000101011000111010101010110011111011001011000010011011001010000101111011001111"
+             "011101100011000001101111001001110011110100111111101000100011010111010000100111101011001111100001000111011100111111110011001011010011011110001111101011101011001011011011111110000"
+             "100101011001110000000001000111111011101110110010010000010010010010001010011011101001100011110000001111011101000101101010011010111001110001010001001011011011110011110100010001111"
+             "111000100111011110111110101101111011101100001011101110010001010110000000001110100111101101000111101010010000100111000111111101101000011010111010111111011001011000011011101011001"
+             "011001000111000100000101010010110111100011101110110111001010110001101101110110101110001011000011000000010111110010100011011010011111101011000011010000000110011111011010110011011"
+             "010101101111010111010011100001011000101011100110001000010110111000101001010110011011100011100111010001001111110101111100110111101011011011011000001011011001010000110111011001111"
+             "011000011000101101000110111100101010011101001001001111100001100100101101101111001101011010100101100100010101010001111011001011010101010110001111001100101110001011011010011110010"
+             "010101101110001011100000100001100000101101010110000101010010000000100010110010011110110011101111000001000000101111000000010010111001110001010001011011011011110011111101110001111"
+             "011101001110011110110000000010001000010010010010011001111111001011101111001001001010110000010010010101110010100001011111111101001110001010111010100111011001011000000011101011001"
+             "110011100101100110100010110011111000110000011001100001101010011000010010010110011110010010100000100100010100000100101011011011010001111101000011011000000110011111011011010011011"
+             "111001000010001001110001001010010110000110001011011000100000000000111000100101001100010010110010010001000111001001110100110110001011000011011000001011011011110001010110001011101"
+             "101011111010000100111011101011101011100011101110110101110011110100101011111110000110010100111011010101010100111000101011001011010101010110001111010100101110001011001011011110010"
+             "011110011010001011011111110101100111001001110000100011100101010011011101011000100110100000111000011110000101001101010000010011011011101001011001011011011011110011110101110001111"
+             "010111111001110000101100100011111110011100101100110001101111111110100100111010010110111111110111101110101100110011111111011001111010010010111111111111011001011000011011111111001"
+             "011110001011010100011001100010001000100000001100101101101000100110111000001100010101100010110011101100101101100110001011011010010111111101011000111010010011011111111001100011010"
+             "110110101000001010100011001010101111000011110001101001011010101001100010101110010101101011001010110111001011110110101010110110001011000011101010111011011011110001001111101011101"
+             "100010001000010111010100111110001010111011110001111100011000110110000101011101100011100011011010000011000010110010001011001011010011011110001000101100101110001011010011100010010"
+             "001011111011000110001010110111111100011010111101001111111111110100111100001101101000111110111101011000001100000011111000010111111001011011011111111011011011110011111101111111111"
+             "101001000001011110001001111100011110001110001111111100101100011110001011011000101111111101111101101011110111000100111111011000011110001010110010111111101101001010011010001010011"
+             "001011100010001010010010000101001110111110011010111011011000010011001000010000011000010001101011101101011001110110100001011010010111111101011011010010010011011111101001011101010"
+             "010111010111110111010100000101000000010110001010001000010101011111000011110000101001100000100101111001101001001001100010110111001011011011111000001011011011110001011111101011101"
+             "010010111110100010001110001001100110111111101000111100001111101010101100010111010011110001110101011100010100110110011011001000110000110110010111011100101110001011011010011110010"
+             "110000010100100101010100110010101001001000110011001110001011001100100000010001110011011011101111010001000101101010000000010111011111001011001001011011010011111011111011010001011"
+             "001000111111001011001111111001110101111010011101111111111001111001110011101111001100011111011010000111111110100101000111001000011110001011010011110111101101001110011010111000011"
+             "101001000011001000000101000011011000010111011011011110001101110011010000111101101111000011111011011001011100010010101001011011110011111101011101001010010011011011110001011011010"
+             "010010101011010001100100011010001010110000110101001111100000001101110101101010111100000000100100101110000011000110000011110011001101010011111010010011011011110011001110001111101"
+             "101101001110110000000010010010011111101011100101011001011110101001000111001100110111110010010000101000100110010111000011001001010010101110011011011001011110011011011001011011011"
+             "011100100101010111000100000110101110010110100101011011011001011011000001000100110010011001011001000100100100110111000000011111111111001010001000000011110011111011100011100001000"
+             "010110011001101111000000100011111111001011100101011011001001101011011110100101001100110101111000110110000010110011100111001000011000011011010011111110001101001000011011011010011"
+             "100101100000111001001110010010110000011111100101011011110101110011101110111100110011111100101001011011110000010001110000011011111011000001111011011011110011011111101000011011001"
+             "000011011001011000101000100010011000101000000000011000011100100000100111101011000111101010100111111010101110110001010011110011001011011010010000010111011001000010001111001000101"
+             "100111111011100111001001011001000111010111111011011110001101000011010010001111101011011010001111010111001101110000011011011001010010101110011011111000111110011101010001111011010"
+             "111000001101010000001100001110101010000111100011010000011100011001110101010000110110110000011100101001111011101010001000011111111011010011001110011011010011111011111011000011011"
+             "101111110111001111001000001000111100101001011000011110010000101100111000110110000000110101111111100100001111101000111111101000000110011110110011110111001101001110001011011100001"
+             "110000000010001111110100001111100010110000110111000110101010111101011111010110010011110000110000010001010010011100100000011011111011011001011001011001110010111111001001011011001"
+             "011001101010110001010001001001100000001110111110001111101001001010011101111000001111000011100100101011000010101100110111100010001011011010000001001111011001000000010111001000110"
+             "111001010001001101110000010110100101100111111011000011000011110011011011101010000111010101011010010001111010111110101011011001010000111111111111111001011110011011011001011111011"
+             "110100101011110010011000001010000011100110101111010100100011100110000000100110101110000000101000000100001101111111101001011111111111001001001010010011110011111111111010100001011"
+             "001111000101110010110000111010010101011101000010011000011101101100100110011111010100111001000011101111110000010110000111101000000010011111011101110011001011001111001011011010001"
+             "111010100011101001111110110101001001100001010001010000101011110100011010011011101000111001111101110010111111111101101010011011011011011001011001001000010010111001011001110011011"
+             "010111010110101010101101111010111110100001110000010001101101010001101101111111010001110000011011100110010000000100001111100010001001010011000111011111011001000010011110001110111"
+             "111011111000010011001111100111111110101110000110000100101111101000011000110100110011111110101101110100111111100011111011011011011111101010011111100001111110011011000001111111000"
+             "011110001011010110111010100110001010001100100111100001101000110010010011011011000110100010101100101100010111010110001001011111111001011001011000110011111001010110111110100011111"
+             "011110101101010001000101111010101111010000010000100011011010101011010101111101000111101010111011010000100100101010101011101001000010011111001010101010001011001011010011101010010"
+             "100010001010011001001001010110001001110001101111100000101000111100101101000001101101100010100111001100010001000110001010011011011101010001111000110001010010111011001000100011001"
+             "011011111110100010111111111011111010100110011111011111111111111101101010111100111001111111111010010010000110010011111111100100001010001010011111111110111001000100010111111110110"
+             "110110011010011000001000001011001101110111110010110011110001000111101001111001111111111001101010100100100011110110000011011011011011110011011001100001100110011011000011111001000"
+             "100000111110001101001000011100010101001111111001001111100111100111011111100100000110011010000000110000010011110110011101010110111001011001010010011010011001010000111111000011111"
+             "001000001111011000001101100010010000010010101000101010111110110101101101111101001111011101010011000000110110000000000011101001000010000111101101111011101011001111001010011010001"
+             "110011110001101010000000010110100100111010010110011100000001100010100110101100000110011111010110111001111100111110000010011011011011111000010011001001010010111001010000010111010"
+             "010011011001001100111001001111001010010000001100001101111000110011111110011101110011001111100010110101000001011000100111100100001000011011111011011110111001011100010011101011010"
+             "101100101011101011010101011100111101101000101001100110011000111001110110000100010000110100011011011110011101001101101011011011011011110011011111111001000111111011011011011011011"
+             "100100011001111000011111100000111001111110011100010100010111011110010100010100101011010110111011001110101010100101100101010110111111011000110010010011011000010110101111011011101"
+             "010001101001000111111111001001001011110100111111101001111101010111010110100110101110000100000101000101011100111101111011001011010011011111001011101010001011101001011010011010011"
+             "100101001111110100010001000101100011101100101010010001110000010010001000011010101100100101110000001001011101000100111010011011011001110001010001001011011100110001110101010001110"
+             "111111100001011100101110101101110011101110000011101110100001110110000000001111000000001011000001101100010000100110110111111100001010011011111111011111011011011010011011001111011"
+             "011101001101000000010101010011010111100101110110110110000100010001101001110110001110110101100001000000010110010110110011011011011011101011011111010001100010011111011010110011011"
+             "010000101001010011000011100111001000101111100110001000100011111001001011010111011001011010000001110111001111010011110100110110101111011011011010001010011111110010110111011101110"
+             "010100000000101111011111111100101011011111001001001110100011100101001101101110001101001010000110000000010101010000000011001011010011010111101001101100001011101001011011111010011"
+             "011011101000001001101001000001011000101101010110000101010000000000100110110011011101101110101011100001000000101001101000010011111101110001010111011011011011010011111100010111111"
+             "010000001000011010111001000100001000110000010010011000010110101010001011001000001101101010010000010001110011100011110111111100001010001010011110100111111000011010000011101111000"
+             "110000100101100110100010010111011001010000011001100001001011111000010110010111111010010010000010000110010101100011101011011011010011111101000011011000000111011001011010110001011"
+             "110100000000001101110001001111110110100110001011011000010000000000111110100100101101111101110110010011000111101111010100110110101111000011111100001010011111110011010111011011110"
+             "100001100010000010111011101011110011100001101110110101100011010100101111111111100011010110011111110101010100111101110011001011010011010111101011110101001011001011001010011110001"
+             "011101011000001011011111010001111111101111110000100011010110010011011001011000000000101011011111011000000100001011101000010011111101101000010111011010111001010101110101110111110"
+             "011000100110110100101100100101111110011100101100110001111001011111000000111010010110110100010101101100101101110111000111011000011010010011011000111111011111111010011011101001011"
+             "010001000010110110011000100000110000000110001100101100101000100111111010001101010100011010010010001110101100100110100011011011010011111100100011011010010111011001111001010011011"
+             "111001101111000110100011001011011110100001110001101001100010101001100110101111110101111011101010110001001010110001101010110111001111000011111010011011111011010111001110011011101"
+             "100100011110111101010101111010101010111011110001111101110001110110100011011100000110011011011011000011000011010101100011001011010011011110001011001101001100101001010011011110010"
+             "000111111001011110001011010111111101011010111101001111101111110100111100001100101000111110111111111000001101100111111000010111111101011011111111111011011011010011111100111111111"
+             "101110001101100010001000011010001110101100001111111100101000111110001101011000001111100011011111001001110111000110001111011000011010001011011000111111001111101010011011100010011"
+             "000010101011110000010011100010101110111000011010111011001010110011001010010001111000101010001101101101011001010010101001011011110001111100111010110011010000011111101001101011001"
+             "011010001011111011010100000110001000010100001010001000001000111111000011110000001110100010000011111111101000001010001010110111001111011011011000101010011011110001011110100011111"
+             "010011111101010000001110001011111111111101101000111100011111101010101010011110110101111111010110111010010101010111111011001001010010110111001111111101001011001011011011111110011"
+             "111101001100101111010100010101100000001010110011001110011100001100100010000001110010100010101110010011000100001111000000010111111101001010001011011011010011011011111011110011011"
+             "001001101101010001001110011010001100111000011101111111101011011001110001111110101111001001111111000011111110000101000111001000011010001011010110110111101010001110011011001010011"
+             "101111000111111010000101000101111001110001011011011110011010010011010000101100001010110011111111110101010101110110111001011011110001111101011011001010010111111011110000110101010"
+             "010001100101110101100100111010010010010110110101001111110000001101110101110010111111101010100100101000000011100011111011110011001111010011111010010011011011010011001111001011101"
+             "101111011101111110000011110101101111001001100101011001001011101001000111000100110010010100010010101110110111110010110011001001010010101110010001011001011011011011010000011001011"
+             "011110111011001001000100100111100110010000100101011011001101011011000011000100110011000001011001001100100101110111001000011111111011001010001111000011101000011011111011010111000"
+             "010101000010011011000000100000011111101101100101011011011100001011011100111101001001001101111100111110000011110100110111001000011010011011010010111110010111001000011011001000011"
+             "100111100001010001001111110111011000011001100101011011101000010011101100111100110111001000101111100011101001110110111000011011111001000001111011011011111011011111110000111101001"
+             "000011010111110000101001000111010001101100000000011000000101000000100001110011000000110000100000100010111110110011111011110011001111011010011000001111011011011010001111001010101"
+             "100110111011010111001000111111101111110011111011011110011111100011010000000111111001010000001010110111000101110110010011011001010000110110011111011000101001010101010000011111010"
+             "111000010001111110001101001110110011000111100011010000011011011001110001010000101100000010001110011001101010101110001000011111111011001011001001000011011111101011111011010001011"
+             "101111111100000111001001101111100100001101011000011110001001101100111100101110011101000111101001001100000110001011010111101000000010011110110011111111011000011110011011011000001"
+             "110001001001111101110100001001011011010000110111000110110101111101011111001110000000101010101100100001000011111110111000011011111001000001011101010001111011011111011000111011001"
+             "011001110001010101000000101010001001101110111110001111111000001010011101110000001011100001111101110011010010001110011111100010001111011010010010001111011100110000001111001110110"
+             "111011011101110001101000110000010101000111111011000011001110110011011111101010010001100011000010110001110011111101011011011001010000110111111011011001010011001011010000011011011"
+             "110111110001010010010001001110101010000110101111010100111001000110000110111110101111011000101101011100001100111011001001011111111011001001001000000011101010010111111011000001011"
+             "001101000010111010111001111011101101011101000010011000010001101100100010001111010101001101001001010111100000110101110111101000000010011111010011111011011000011111000011011010001"
+             "111000110111000001100111010010111001000001010001010000101101110100011100011011101000101101111100111010111111111101111010011011011001011001010011010000000011100001011000111011011"
+             "010111010010111010111100011110001110100001110000010001101100110001101101100111000111110010011100100110011001100101000111100010001111011011011000001111011011011010001111001000111"
+             "111001110001000011010110100111010110101110000110000100100101001000011010101100100110110010111001101100100110100110011011011011011001110010001011111001101000011011010000011011000"
+             "011110010100100110100010100000110011001100100111100001100100010010010101000011001000111000100111110100000111110110001001011111111011001001011110011011101010010110111111000010111"
+             "111001100100100001001101111100110110010000010000100011011000101011010011111101010000000100101111011000100100001110110011101001000010010111010011111010010111111011000011011101110"
+             "000100010011011001111000010111111000110001101111100000101010111100101111010001111101110000101001110100000001000100111010011011011001011001111001010001011011011011011001111010101"
+             "010101101110101010110110011011111010100110011111011111101111111101101010100100100100111111101001001010001110010111111111100100001110011010011111101110101001010100001111111110110"
+             "000000001011110001011001101110001101110111110010110011111000100111101001101001111000100011111110101100100010110110001011011011011001110011011000110001101000011011011011100011000"
+             "111111100111010101010000111110101101101111111001001111101010100111011111111100000000101010010101101000011010110010101101010110111111001001011010111010010111001000111110101011011"
+             "100000100111000001110100100110001000010010101000101010101000110101101101100101000011100010011110110000110110000110001011101001000010010111101000111011111011011111000011100010001"
+             "101110101000010010001001010011111101011010010110011100011111100010100110110100000010111110101011001001100101111011111010011011011001111000001111110001011100110001011001111111010"
+             "101110101000101101011000101111110010010000001100001101101001010011111110011100010010011011010001110101001001111110100111100100001110011011111001001110101001010100001010101001011"
+             "101110101010001011100101111010101100101000101001100110010011111001110110010100001111001101110110111110001101101110111011011011011011110011010111110001011111101011011011011111100"
+             "100000100000010000101110000100011000011110011100010100000011111110010100001100010010001001110010000000110010100111101101010110111111001000101010011011011000011110111110000000000"
+             "111111100000001110110110101010011010010100111111101001111101110111010110101111000111011001110100010111000100111000011011001011010011010011010101111010000011100001000011111011001"},
+    /* 25*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 4, -1, ZINT_FULL_MULTIBYTE, {0, 0, ""}, "áA", -1, 0, 21, 21, 1, "Mask automatic (001)", "111111100101101111111"
+                                                                                                                                       "100000101001101000001"
+                                                                                                                                       "101110101010101011101"
+                                                                                                                                       "101110101001101011101"
+                                                                                                                                       "101110101101001011101"
+                                                                                                                                       "100000101010001000001"
+                                                                                                                                       "111111101010101111111"
+                                                                                                                                       "000000000001100000000"
+                                                                                                                                       "001001111011010111110"
+                                                                                                                                       "101000001010010000100"
+                                                                                                                                       "100111100000110001111"
+                                                                                                                                       "110000000001000010000"
+                                                                                                                                       "011010110111010001111"
+                                                                                                                                       "000000001100011101100"
+                                                                                                                                       "111111101011111111000"
+                                                                                                                                       "100000101101010101110"
+                                                                                                                                       "101110100001000111111"
+                                                                                                                                       "101110100101010000000"
+                                                                                                                                       "101110101001111000111"
+                                                                                                                                       "100000100100111010000"
+                                                                                                                                       "111111100011001000110"},
+    /* 26*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 4, -1, ZINT_FULL_MULTIBYTE | (8 << 8), {0, 0, ""}, "áA", -1, 0, 21, 21, 1, "Mask 111", "111111101000101111111"
+                                                                                                                                      "100000101110101000001"
+                                                                                                                                      "101110100110101011101"
+                                                                                                                                      "101110101100101011101"
+                                                                                                                                      "101110101010001011101"
+                                                                                                                                      "100000101110001000001"
+                                                                                                                                      "111111101010101111111"
+                                                                                                                                      "000000000110100000000"
+                                                                                                                                      "000100100111000111011"
+                                                                                                                                      "111101011111000101110"
+                                                                                                                                      "100000100111110110111"
+                                                                                                                                      "101100011101011110011"
+                                                                                                                                      "001111100010000100101"
+                                                                                                                                      "000000001011011010100"
+                                                                                                                                      "111111100111100011011"
+                                                                                                                                      "100000100000000000100"
+                                                                                                                                      "101110100110000000111"
+                                                                                                                                      "101110101001001100011"
+                                                                                                                                      "101110100100101101101"
+                                                                                                                                      "100000100011111101000"
+                                                                                                                                      "111111100111010100101"},
+    /* 27*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 4, -1, ZINT_FULL_MULTIBYTE | (9 << 8), {0, 0, ""}, "áA", -1, 0, 21, 21, 1, "Mask > 111 ignored", "111111100101101111111"
+                                                                                                                                                "100000101001101000001"
+                                                                                                                                                "101110101010101011101"
+                                                                                                                                                "101110101001101011101"
+                                                                                                                                                "101110101101001011101"
+                                                                                                                                                "100000101010001000001"
+                                                                                                                                                "111111101010101111111"
+                                                                                                                                                "000000000001100000000"
+                                                                                                                                                "001001111011010111110"
+                                                                                                                                                "101000001010010000100"
+                                                                                                                                                "100111100000110001111"
+                                                                                                                                                "110000000001000010000"
+                                                                                                                                                "011010110111010001111"
+                                                                                                                                                "000000001100011101100"
+                                                                                                                                                "111111101011111111000"
+                                                                                                                                                "100000101101010101110"
+                                                                                                                                                "101110100001000111111"
+                                                                                                                                                "101110100101010000000"
+                                                                                                                                                "101110101001111000111"
+                                                                                                                                                "100000100100111010000"
+                                                                                                                                                "111111100011001000110"},
+    /* 28*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 2, 1, -1, {0, 0, ""}, "1234567890", -1, 0, 21, 21, 0, "test_print example, automatic mask 001 (same score as mask 010); BWIPP uses mask 010", "111111101001101111111"
+                                                                                                                                                                                             "100000100100101000001"
+                                                                                                                                                                                             "101110101001001011101"
+                                                                                                                                                                                             "101110100101101011101"
+                                                                                                                                                                                             "101110100001101011101"
+                                                                                                                                                                                             "100000101101101000001"
+                                                                                                                                                                                             "111111101010101111111"
+                                                                                                                                                                                             "000000000000100000000"
+                                                                                                                                                                                             "101000110010000100101"
+                                                                                                                                                                                             "101010001111011101011"
+                                                                                                                                                                                             "111010101101110110010"
+                                                                                                                                                                                             "110111010101011100011"
+                                                                                                                                                                                             "110111110101111111001"
+                                                                                                                                                                                             "000000001010000000000"
+                                                                                                                                                                                             "111111101110001000010"
+                                                                                                                                                                                             "100000100000100010001"
+                                                                                                                                                                                             "101110100110001000111"
+                                                                                                                                                                                             "101110100111011001000"
+                                                                                                                                                                                             "101110101101110110111"
+                                                                                                                                                                                             "100000100001011000010"
+                                                                                                                                                                                             "111111101011111111111"},
+    /* 29*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 2, 1, 3 << 8, {0, 0, ""}, "1234567890", -1, 0, 21, 21, 1, "test_print example, explicit mask 010", "111111100010101111111"
+                                                                                                                                                  "100000100000001000001"
+                                                                                                                                                  "101110101010001011101"
+                                                                                                                                                  "101110101001001011101"
+                                                                                                                                                  "101110101010101011101"
+                                                                                                                                                  "100000101001001000001"
+                                                                                                                                                  "111111101010101111111"
+                                                                                                                                                  "000000001100000000000"
+                                                                                                                                                  "101111100001001111100"
+                                                                                                                                                  "001110001011111001111"
+                                                                                                                                                  "100001110110101101001"
+                                                                                                                                                  "010011010001111000111"
+                                                                                                                                                  "101100101110100100010"
+                                                                                                                                                  "000000001110100100100"
+                                                                                                                                                  "111111100101010011001"
+                                                                                                                                                  "100000101100000110101"
+                                                                                                                                                  "101110101101010011100"
+                                                                                                                                                  "101110101011111101100"
+                                                                                                                                                  "101110101110101101100"
+                                                                                                                                                  "100000100101111100110"
+                                                                                                                                                  "111111101000100100100"},
+    /* 30*/ {BARCODE_QRCODE, UNICODE_MODE, -1, 1, 2, 2 << 8, {0, 0, ""}, "?ややややwやややや ややややや", -1, ZINT_WARN_NONCOMPLIANT, 25, 25, 1, "Data with Shift JIS '2nd byte 1st byte' matches; explicit mask 001 (auto 000) to match BWIPP", "1111111010111110001111111"
+                                                                                                                                                                                                                                                 "1000001011100101001000001"
+                                                                                                                                                                                                                                                 "1011101000111110101011101"
+                                                                                                                                                                                                                                                 "1011101000101100001011101"
+                                                                                                                                                                                                                                                 "1011101011111111101011101"
+                                                                                                                                                                                                                                                 "1000001010001001001000001"
+                                                                                                                                                                                                                                                 "1111111010101010101111111"
+                                                                                                                                                                                                                                                 "0000000010110101000000000"
+                                                                                                                                                                                                                                                 "1110011011101111111110011"
+                                                                                                                                                                                                                                                 "1001010001100001111100001"
+                                                                                                                                                                                                                                                 "1101101110011110101101000"
+                                                                                                                                                                                                                                                 "1011110011010001011000101"
+                                                                                                                                                                                                                                                 "0011101011011101110101111"
+                                                                                                                                                                                                                                                 "0010100010011010000110000"
+                                                                                                                                                                                                                                                 "1111111111110110111101010"
+                                                                                                                                                                                                                                                 "0010010111100101001001111"
+                                                                                                                                                                                                                                                 "1111011011011011111111000"
+                                                                                                                                                                                                                                                 "0000000010101010100010011"
+                                                                                                                                                                                                                                                 "1111111000011110101011011"
+                                                                                                                                                                                                                                                 "1000001011001011100010111"
+                                                                                                                                                                                                                                                 "1011101000101110111111111"
+                                                                                                                                                                                                                                                 "1011101000110000111000010"
+                                                                                                                                                                                                                                                 "1011101010111101110101011"
+                                                                                                                                                                                                                                                 "1000001010100110000011100"
+                                                                                                                                                                                                                                                 "1111111011001111010111001"},
+    /* 31*/ {BARCODE_QRCODE, UNICODE_MODE, 3, 2, -1, 5 << 8, {0, 0, ""}, "sn:7QPB4MN", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 3 Example 1 **NOT SAME** different encodation; explicit mask 100 (auto 011) to match BWIPP", "111111101011101111111"
+                                                                                                                                                                                                                               "100000100001001000001"
+                                                                                                                                                                                                                               "101110100110001011101"
+                                                                                                                                                                                                                               "101110101010101011101"
+                                                                                                                                                                                                                               "101110101000101011101"
+                                                                                                                                                                                                                               "100000101001001000001"
+                                                                                                                                                                                                                               "111111101010101111111"
+                                                                                                                                                                                                                               "000000001111100000000"
+                                                                                                                                                                                                                               "100010111111011111001"
+                                                                                                                                                                                                                               "110010011111101101110"
+                                                                                                                                                                                                                               "001110111011001010100"
+                                                                                                                                                                                                                               "000010010100010011000"
+                                                                                                                                                                                                                               "010111101100100011011"
+                                                                                                                                                                                                                               "000000001100100111111"
+                                                                                                                                                                                                                               "111111101100100111110"
+                                                                                                                                                                                                                               "100000100011111110111"
+                                                                                                                                                                                                                               "101110101011001110011"
+                                                                                                                                                                                                                               "101110100010100110111"
+                                                                                                                                                                                                                               "101110100011011011100"
+                                                                                                                                                                                                                               "100000100101001111011"
+                                                                                                                                                                                                                               "111111101000010100101"},
+    /* 32*/ {BARCODE_QRCODE, UNICODE_MODE, 3, 2, -1, -1, {0, 0, ""}, "price:£20.00", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 3 Example 2", "111111101111101111111"
+                                                                                                                                              "100000101101001000001"
+                                                                                                                                              "101110100001101011101"
+                                                                                                                                              "101110101100101011101"
+                                                                                                                                              "101110100101001011101"
+                                                                                                                                              "100000100000001000001"
+                                                                                                                                              "111111101010101111111"
+                                                                                                                                              "000000001101000000000"
+                                                                                                                                              "101101110000001001011"
+                                                                                                                                              "000010001100101111100"
+                                                                                                                                              "101011110111000010110"
+                                                                                                                                              "101000010101110100010"
+                                                                                                                                              "010100101010111100100"
+                                                                                                                                              "000000001101001100001"
+                                                                                                                                              "111111101010001111100"
+                                                                                                                                              "100000101101000110111"
+                                                                                                                                              "101110100001000101101"
+                                                                                                                                              "101110101000110101010"
+                                                                                                                                              "101110101011011100000"
+                                                                                                                                              "100000100101101011110"
+                                                                                                                                              "111111101100010111000"},
+    /* 33*/ {BARCODE_QRCODE, UNICODE_MODE, 3, 1, -1, -1, {0, 0, ""}, "C:\\DOCS\\EXAMPLE.TXT", -1, 0, 25, 25, 0, "AIM ITS/04-023:2022 ECI 3 Example 3 **NOT SAME** different encodation; BWIPP same encodation as Zint but uses mask 000 instead of 100", "1111111011101001001111111"
+                                                                                                                                                                                                                                                         "1000001011100010101000001"
+                                                                                                                                                                                                                                                         "1011101010110001001011101"
+                                                                                                                                                                                                                                                         "1011101011010111101011101"
+                                                                                                                                                                                                                                                         "1011101000000100001011101"
+                                                                                                                                                                                                                                                         "1000001010011100101000001"
+                                                                                                                                                                                                                                                         "1111111010101010101111111"
+                                                                                                                                                                                                                                                         "0000000001001001000000000"
+                                                                                                                                                                                                                                                         "1100111000010110100101111"
+                                                                                                                                                                                                                                                         "1001100001101010001000010"
+                                                                                                                                                                                                                                                         "0010111100011110110100010"
+                                                                                                                                                                                                                                                         "1111000100110100011101010"
+                                                                                                                                                                                                                                                         "1110111100101101101000111"
+                                                                                                                                                                                                                                                         "1000000010000110001111001"
+                                                                                                                                                                                                                                                         "0001011110100001000100111"
+                                                                                                                                                                                                                                                         "0011010001101011100100010"
+                                                                                                                                                                                                                                                         "1110001111110110111110001"
+                                                                                                                                                                                                                                                         "0000000010101001100011001"
+                                                                                                                                                                                                                                                         "1111111000111110101011100"
+                                                                                                                                                                                                                                                         "1000001010010101100010101"
+                                                                                                                                                                                                                                                         "1011101011001101111110001"
+                                                                                                                                                                                                                                                         "1011101001000111100001001"
+                                                                                                                                                                                                                                                         "1011101001100001111001110"
+                                                                                                                                                                                                                                                         "1000001011001010011000001"
+                                                                                                                                                                                                                                                         "1111111011010111011011111"},
+    /* 34*/ {BARCODE_QRCODE, UNICODE_MODE, 3, 1, -1, 1 << 8, {0, 0, ""}, "C:\\DOCS\\EXAMPLE.TXT", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 3 Example 3 **NOT SAME** different encodation", "1111111001001101101111111"
+                                                                                                                                                                                             "1000001000111001101000001"
+                                                                                                                                                                                             "1011101011101010001011101"
+                                                                                                                                                                                             "1011101001110011001011101"
+                                                                                                                                                                                             "1011101000100000101011101"
+                                                                                                                                                                                             "1000001001000111101000001"
+                                                                                                                                                                                             "1111111010101010101111111"
+                                                                                                                                                                                             "0000000011101101100000000"
+                                                                                                                                                                                             "1110111110110010011000100"
+                                                                                                                                                                                             "0010110010110001010011001"
+                                                                                                                                                                                             "1001101111000101101111001"
+                                                                                                                                                                                             "1011100000010000111001110"
+                                                                                                                                                                                             "1010011000001001001100011"
+                                                                                                                                                                                             "0011010001011101010100010"
+                                                                                                                                                                                             "1010001101111010011111100"
+                                                                                                                                                                                             "0111110101001111000000110"
+                                                                                                                                                                                             "1010101011010010111110101"
+                                                                                                                                                                                             "0000000011110010100010010"
+                                                                                                                                                                                             "1111111011100101101010111"
+                                                                                                                                                                                             "1000001010110001100010001"
+                                                                                                                                                                                             "1011101011101001111110101"
+                                                                                                                                                                                             "1011101000011100111010010"
+                                                                                                                                                                                             "1011101010111010100010101"
+                                                                                                                                                                                             "1000001011101110111100101"
+                                                                                                                                                                                             "1111111011110011111111011"},
+    /* 35*/ {BARCODE_QRCODE, UNICODE_MODE, 4, 1, -1, -1, {0, 0, ""}, "Študentska št. 2198390", -1, 0, 25, 25, 0, "AIM ITS/04-023:2022 ECI 4 Example 1 **NOT SAME** different encodation; BWIPP same encodation as Zint but uses mask 011 instead of 100", "1111111010000110001111111"
+                                                                                                                                                                                                                                                          "1000001010011110101000001"
+                                                                                                                                                                                                                                                          "1011101011001111101011101"
+                                                                                                                                                                                                                                                          "1011101011101011101011101"
+                                                                                                                                                                                                                                                          "1011101001101010001011101"
+                                                                                                                                                                                                                                                          "1000001011100100001000001"
+                                                                                                                                                                                                                                                          "1111111010101010101111111"
+                                                                                                                                                                                                                                                          "0000000000110110100000000"
+                                                                                                                                                                                                                                                          "1100111000101010000101111"
+                                                                                                                                                                                                                                                          "1111100110000001110111011"
+                                                                                                                                                                                                                                                          "1110111101100010100110011"
+                                                                                                                                                                                                                                                          "0000000111001010111100111"
+                                                                                                                                                                                                                                                          "1010101010010110000110000"
+                                                                                                                                                                                                                                                          "1110110000101000110011010"
+                                                                                                                                                                                                                                                          "0010001010011011000110001"
+                                                                                                                                                                                                                                                          "0001100010110000011100110"
+                                                                                                                                                                                                                                                          "1110011100101110111111001"
+                                                                                                                                                                                                                                                          "0000000011000111100011001"
+                                                                                                                                                                                                                                                          "1111111000100001101011000"
+                                                                                                                                                                                                                                                          "1000001011001001100010110"
+                                                                                                                                                                                                                                                          "1011101010010111111110011"
+                                                                                                                                                                                                                                                          "1011101000101011101101001"
+                                                                                                                                                                                                                                                          "1011101001111111000111010"
+                                                                                                                                                                                                                                                          "1000001011110101110010101"
+                                                                                                                                                                                                                                                          "1111111010101100000011011"},
+    /* 36*/ {BARCODE_QRCODE, UNICODE_MODE, 4, 1, -1, 4 << 8, {0, 0, ""}, "Študentska št. 2198390", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 4 Example 1 **NOT SAME** different encodation", "1111111011000001001111111"
+                                                                                                                                                                                              "1000001000000010101000001"
+                                                                                                                                                                                              "1011101010011010101011101"
+                                                                                                                                                                                              "1011101011010011001011101"
+                                                                                                                                                                                              "1011101011110110001011101"
+                                                                                                                                                                                              "1000001001001110101000001"
+                                                                                                                                                                                              "1111111010101010101111111"
+                                                                                                                                                                                              "0000000001010101000000000"
+                                                                                                                                                                                              "1111001010000000110011101"
+                                                                                                                                                                                              "1000100001000110110000011"
+                                                                                                                                                                                              "1101011110000001000101111"
+                                                                                                                                                                                              "0101010010011111101001101"
+                                                                                                                                                                                              "1101101101010001000001000"
+                                                                                                                                                                                              "0010100100110100101111001"
+                                                                                                                                                                                              "0111011111001110010011011"
+                                                                                                                                                                                              "1001010010001000100100001"
+                                                                                                                                                                                              "0010001000110010111111010"
+                                                                                                                                                                                              "0000000011101101100011100"
+                                                                                                                                                                                              "1111111000011001101011111"
+                                                                                                                                                                                              "1000001000101010100011010"
+                                                                                                                                                                                              "1011101000111101111110110"
+                                                                                                                                                                                              "1011101011101100101010001"
+                                                                                                                                                                                              "1011101010011100100100110"
+                                                                                                                                                                                              "1000001010100000100111111"
+                                                                                                                                                                                              "1111111011101011000100011"},
+    /* 37*/ {BARCODE_QRCODE, UNICODE_MODE, 4, 1, -1, -1, {0, 0, ""}, "Szczegółowe dane kontaktowe:+48 22 694 60 00", -1, 0, 29, 29, 0, "AIM ITS/04-023:2022 ECI 4 Example 2 **NOT SAME** different encodation; BWIPP same encodation as example but uses mask 100 instead of 111", "11111110000111011111001111111"
+                                                                                                                                                                                                                                                                                   "10000010011001101100101000001"
+                                                                                                                                                                                                                                                                                   "10111010000010110011101011101"
+                                                                                                                                                                                                                                                                                   "10111010100010100010101011101"
+                                                                                                                                                                                                                                                                                   "10111010110001101001101011101"
+                                                                                                                                                                                                                                                                                   "10000010000111011101001000001"
+                                                                                                                                                                                                                                                                                   "11111110101010101010101111111"
+                                                                                                                                                                                                                                                                                   "00000000001100110111100000000"
+                                                                                                                                                                                                                                                                                   "11000111010100010110100011000"
+                                                                                                                                                                                                                                                                                   "11100000010010101001011111100"
+                                                                                                                                                                                                                                                                                   "10010111001000101101010000111"
+                                                                                                                                                                                                                                                                                   "11001101110010001001101110011"
+                                                                                                                                                                                                                                                                                   "10000110010110110101011000001"
+                                                                                                                                                                                                                                                                                   "01101101110001100011000111011"
+                                                                                                                                                                                                                                                                                   "11001111001111001101000101110"
+                                                                                                                                                                                                                                                                                   "10111100100100001111000110011"
+                                                                                                                                                                                                                                                                                   "00001010101101001100000100100"
+                                                                                                                                                                                                                                                                                   "10010001001011011000000101011"
+                                                                                                                                                                                                                                                                                   "11110110011100110001101101010"
+                                                                                                                                                                                                                                                                                   "10001101011010000001001111010"
+                                                                                                                                                                                                                                                                                   "10110111101010010100111111010"
+                                                                                                                                                                                                                                                                                   "00000000111000100001100011101"
+                                                                                                                                                                                                                                                                                   "11111110110110010100101010100"
+                                                                                                                                                                                                                                                                                   "10000010111100011011100011000"
+                                                                                                                                                                                                                                                                                   "10111010001001100101111110001"
+                                                                                                                                                                                                                                                                                   "10111010010011011000100101100"
+                                                                                                                                                                                                                                                                                   "10111010000001100111000011110"
+                                                                                                                                                                                                                                                                                   "10000010110011101010011100110"
+                                                                                                                                                                                                                                                                                   "11111110101010100011111001100"},
+    /* 38*/ {BARCODE_QRCODE, UNICODE_MODE, 5, 1, -1, -1, {0, 0, ""}, "Liĥtenŝtejno", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 5 Example 1; BWIPP uses mask 011 instead of 101", "111111100111101111111"
+                                                                                                                                                                                  "100000100101001000001"
+                                                                                                                                                                                  "101110100100001011101"
+                                                                                                                                                                                  "101110101111001011101"
+                                                                                                                                                                                  "101110101010101011101"
+                                                                                                                                                                                  "100000100010101000001"
+                                                                                                                                                                                  "111111101010101111111"
+                                                                                                                                                                                  "000000000110100000000"
+                                                                                                                                                                                  "110001110100100011000"
+                                                                                                                                                                                  "111011000001010001101"
+                                                                                                                                                                                  "100100111011011010111"
+                                                                                                                                                                                  "100101010110011011000"
+                                                                                                                                                                                  "100011101010110011111"
+                                                                                                                                                                                  "000000001100010101100"
+                                                                                                                                                                                  "111111101001011000010"
+                                                                                                                                                                                  "100000101010011000011"
+                                                                                                                                                                                  "101110100011100001110"
+                                                                                                                                                                                  "101110100000010000000"
+                                                                                                                                                                                  "101110100111010010011"
+                                                                                                                                                                                  "100000101010010111111"
+                                                                                                                                                                                  "111111101011110000010"},
+    /* 39*/ {BARCODE_QRCODE, UNICODE_MODE, 5, 1, -1, 4 << 8, {0, 0, ""}, "Liĥtenŝtejno", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 5 Example 1 **NOT SAME** explicit mask 011", "111111101100101111111"
+                                                                                                                                                                                 "100000100100101000001"
+                                                                                                                                                                                 "101110101010101011101"
+                                                                                                                                                                                 "101110101001001011101"
+                                                                                                                                                                                 "101110101111001011101"
+                                                                                                                                                                                 "100000100000001000001"
+                                                                                                                                                                                 "111111101010101111111"
+                                                                                                                                                                                 "000000000111000000000"
+                                                                                                                                                                                 "111100101010010011101"
+                                                                                                                                                                                 "110101001111011111100"
+                                                                                                                                                                                 "001001110110110111010"
+                                                                                                                                                                                 "010111000100101001110"
+                                                                                                                                                                                 "111000110001101000100"
+                                                                                                                                                                                 "000000001101111100001"
+                                                                                                                                                                                 "111111100111101110100"
+                                                                                                                                                                                 "100000100100010110010"
+                                                                                                                                                                                 "101110100110001100011"
+                                                                                                                                                                                 "101110101010100010110"
+                                                                                                                                                                                 "101110101100001001000"
+                                                                                                                                                                                 "100000101011111110010"
+                                                                                                                                                                                 "111111101101000110100"},
+    /* 40*/ {BARCODE_QRCODE, UNICODE_MODE, 6, 1, -1, -1, {0, 0, ""}, "Lietuvą", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 6 Example 1", "111111101000101111111"
+                                                                                                                                         "100000101010001000001"
+                                                                                                                                         "101110100000101011101"
+                                                                                                                                         "101110100000001011101"
+                                                                                                                                         "101110101111101011101"
+                                                                                                                                         "100000101101101000001"
+                                                                                                                                         "111111101010101111111"
+                                                                                                                                         "000000001000100000000"
+                                                                                                                                         "111001101010011110011"
+                                                                                                                                         "111111001101001011011"
+                                                                                                                                         "100011101001100011101"
+                                                                                                                                         "000011011001000111100"
+                                                                                                                                         "110100101001101011111"
+                                                                                                                                         "000000001110000101000"
+                                                                                                                                         "111111100010011011001"
+                                                                                                                                         "100000101010100110101"
+                                                                                                                                         "101110100110011010101"
+                                                                                                                                         "101110100001011001000"
+                                                                                                                                         "101110101101110011011"
+                                                                                                                                         "100000101011011111011"
+                                                                                                                                         "111111101111111010101"},
+    /* 41*/ {BARCODE_QRCODE, UNICODE_MODE, 7, 1, -1, -1, {0, 0, ""}, "Россия", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 7 Example 1", "111111100010101111111"
+                                                                                                                                        "100000101010101000001"
+                                                                                                                                        "101110101011001011101"
+                                                                                                                                        "101110100000101011101"
+                                                                                                                                        "101110101111101011101"
+                                                                                                                                        "100000101110001000001"
+                                                                                                                                        "111111101010101111111"
+                                                                                                                                        "000000001000000000000"
+                                                                                                                                        "110100110011101110110"
+                                                                                                                                        "101000010001010010111"
+                                                                                                                                        "110010110011011110101"
+                                                                                                                                        "101011010000111110011"
+                                                                                                                                        "100001101011001100101"
+                                                                                                                                        "000000001010011110100"
+                                                                                                                                        "111111101001101000110"
+                                                                                                                                        "100000100110001000101"
+                                                                                                                                        "101110100000111110001"
+                                                                                                                                        "101110101010011001111"
+                                                                                                                                        "101110100111011010001"
+                                                                                                                                        "100000101011100101011"
+                                                                                                                                        "111111101100010100110"},
+    /* 42*/ {BARCODE_QRCODE, UNICODE_MODE, 7, 1, -1, -1, {0, 0, ""}, "Монголулс", -1, 0, 25, 25, 0, "AIM ITS/04-023:2022 ECI 7 Example 2; BWIPP uses mask 000 instead of 111", "111111100101101111111"
+                                                                                                                                                                               "100000101101001000001"
+                                                                                                                                                                               "101110101100101011101"
+                                                                                                                                                                               "101110100101001011101"
+                                                                                                                                                                               "101110101000101011101"
+                                                                                                                                                                               "100000101001101000001"
+                                                                                                                                                                               "111111101010101111111"
+                                                                                                                                                                               "000000001111100000000"
+                                                                                                                                                                               "110100110110001110110"
+                                                                                                                                                                               "111110010000001011100"
+                                                                                                                                                                               "010110100010110011010"
+                                                                                                                                                                               "100000011011011001111"
+                                                                                                                                                                               "000011110010110100101"
+                                                                                                                                                                               "000000001101011100100"
+                                                                                                                                                                               "111111101010010100110"
+                                                                                                                                                                               "100000100001111000101"
+                                                                                                                                                                               "101110100001000110001"
+                                                                                                                                                                               "101110101110000011111"
+                                                                                                                                                                               "101110100110100011101"
+                                                                                                                                                                               "100000101011000010111"
+                                                                                                                                                                               "111111101001110100110"},
+    /* 43*/ {BARCODE_QRCODE, UNICODE_MODE, 7, 1, -1, 1 << 8, {0, 0, ""}, "Монголулс", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 7 Example 2 **NOT SAME** explicit mask 000", "111111100101101111111"
+                                                                                                                                                                              "100000100111001000001"
+                                                                                                                                                                              "101110101101101011101"
+                                                                                                                                                                              "101110100101001011101"
+                                                                                                                                                                              "101110100010101011101"
+                                                                                                                                                                              "100000100000101000001"
+                                                                                                                                                                              "111111101010101111111"
+                                                                                                                                                                              "000000001101100000000"
+                                                                                                                                                                              "111011111111011000100"
+                                                                                                                                                                              "111110010000001011100"
+                                                                                                                                                                              "000100110000100001000"
+                                                                                                                                                                              "101001010010010000110"
+                                                                                                                                                                              "000011110010110100101"
+                                                                                                                                                                              "000000001111001110110"
+                                                                                                                                                                              "111111101011011101111"
+                                                                                                                                                                              "100000101001111000101"
+                                                                                                                                                                              "101110101011010100011"
+                                                                                                                                                                              "101110100111001010110"
+                                                                                                                                                                              "101110101110100011101"
+                                                                                                                                                                              "100000101001010000101"
+                                                                                                                                                                              "111111101000111101111"},
+    /* 44*/ {BARCODE_QRCODE, UNICODE_MODE, 8, 1, -1, -1, {0, 0, ""}, "جواز السفر", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 8 Example 1", "111111100010101111111"
+                                                                                                                                            "100000101010101000001"
+                                                                                                                                            "101110101011001011101"
+                                                                                                                                            "101110100000101011101"
+                                                                                                                                            "101110101111101011101"
+                                                                                                                                            "100000101110001000001"
+                                                                                                                                            "111111101010101111111"
+                                                                                                                                            "000000001000000000000"
+                                                                                                                                            "110100110011101110110"
+                                                                                                                                            "010000010011001010111"
+                                                                                                                                            "100011101101010100110"
+                                                                                                                                            "111110010000101101111"
+                                                                                                                                            "100010100111001100101"
+                                                                                                                                            "000000001101011110100"
+                                                                                                                                            "111111101011110011010"
+                                                                                                                                            "100000100001010111110"
+                                                                                                                                            "101110100010100000110"
+                                                                                                                                            "101110101011000111111"
+                                                                                                                                            "101110100000100010101"
+                                                                                                                                            "100000101110000010011"
+                                                                                                                                            "111111101000010100010"},
+    /* 45*/ {BARCODE_QRCODE, UNICODE_MODE, 8, 1, -1, -1, {0, 0, ""}, "المنشأ: المملكة العربية السعودية", -1, 0, 33, 33, 0, "AIM ITS/04-023:2022 ECI 8 Example 2; BWIPP uses mask 000 instead of 010", "11111110001011110110001111111"
+                                                                                                                                                                                                      "10000010101001111101001000001"
+                                                                                                                                                                                                      "10111010000011010110101011101"
+                                                                                                                                                                                                      "10111010111010110111101011101"
+                                                                                                                                                                                                      "10111010010000011110001011101"
+                                                                                                                                                                                                      "10000010110110000000101000001"
+                                                                                                                                                                                                      "11111110101010101010101111111"
+                                                                                                                                                                                                      "00000000011100101110100000000"
+                                                                                                                                                                                                      "11111011110100000011110101010"
+                                                                                                                                                                                                      "10000100101011110000000111110"
+                                                                                                                                                                                                      "11110011101001110111101000100"
+                                                                                                                                                                                                      "10001100000011010010111101011"
+                                                                                                                                                                                                      "00001011111010111011000011001"
+                                                                                                                                                                                                      "00000001110000010110100111101"
+                                                                                                                                                                                                      "01101010010110000000001000100"
+                                                                                                                                                                                                      "01101100101100111011111101010"
+                                                                                                                                                                                                      "00001111001100000101100100101"
+                                                                                                                                                                                                      "10110100000011100101110111110"
+                                                                                                                                                                                                      "10001110001001100100001011010"
+                                                                                                                                                                                                      "10000101111011001010111101011"
+                                                                                                                                                                                                      "10011010001010101001111110010"
+                                                                                                                                                                                                      "00000000110000001110100011110"
+                                                                                                                                                                                                      "11111110110110000000101010000"
+                                                                                                                                                                                                      "10000010001100111000100010010"
+                                                                                                                                                                                                      "10111010101100000110111111111"
+                                                                                                                                                                                                      "10111010101011110100110010010"
+                                                                                                                                                                                                      "10111010100001100000001011110"
+                                                                                                                                                                                                      "10000010100011001101001000101"
+                                                                                                                                                                                                      "11111110110010101010110010100"},
+    /* 46*/ {BARCODE_QRCODE, UNICODE_MODE, 8, 1, -1, 1 << 8, {0, 0, ""}, "المنشأ: المملكة العربية السعودية", -1, 0, 33, 33, 1, "AIM ITS/04-023:2022 ECI 8 Example 2 **NOT SAME** explicit mask 000", "11111110010011001110101111111"
+                                                                                                                                                                                                     "10000010001110111010001000001"
+                                                                                                                                                                                                     "10111010111011101110001011101"
+                                                                                                                                                                                                     "10111010011101110000101011101"
+                                                                                                                                                                                                     "10111010001000100110101011101"
+                                                                                                                                                                                                     "10000010010001000111101000001"
+                                                                                                                                                                                                     "11111110101010101010101111111"
+                                                                                                                                                                                                     "00000000111011101001100000000"
+                                                                                                                                                                                                     "11101111101100111011011000100"
+                                                                                                                                                                                                     "01000001101100110111000000110"
+                                                                                                                                                                                                     "11001011010001001111010000011"
+                                                                                                                                                                                                     "01001001000100010101111010011"
+                                                                                                                                                                                                     "00110011000010000011111011110"
+                                                                                                                                                                                                     "11000100110111010001100000101"
+                                                                                                                                                                                                     "01010010101110111000110000011"
+                                                                                                                                                                                                     "10101001101011111100111010010"
+                                                                                                                                                                                                     "00110111110100111101011100010"
+                                                                                                                                                                                                     "01110001000100100010110000110"
+                                                                                                                                                                                                     "10110110110001011100110011101"
+                                                                                                                                                                                                     "01000000111100001101111010011"
+                                                                                                                                                                                                     "10100010110010010001111110101"
+                                                                                                                                                                                                     "00000000110111001001100010110"
+                                                                                                                                                                                                     "11111110101110111000101010111"
+                                                                                                                                                                                                     "10000010101011111111100011010"
+                                                                                                                                                                                                     "10111010110100111110111111000"
+                                                                                                                                                                                                     "10111010001100110011110101010"
+                                                                                                                                                                                                     "10111010111001011000110011001"
+                                                                                                                                                                                                     "10000010100100001010001111101"
+                                                                                                                                                                                                     "11111110101010010010001010011"},
+    /* 47*/ {BARCODE_QRCODE, UNICODE_MODE, 9, 1, -1, -1, {0, 0, ""}, "Μέρος #. α123", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 9 Example 1 **NOT SAME** example uses mask 111 instead of 000", "111111100100101111111"
+                                                                                                                                                                                                 "100000100111001000001"
+                                                                                                                                                                                                 "101110101100101011101"
+                                                                                                                                                                                                 "101110100101001011101"
+                                                                                                                                                                                                 "101110100011001011101"
+                                                                                                                                                                                                 "100000100001101000001"
+                                                                                                                                                                                                 "111111101010101111111"
+                                                                                                                                                                                                 "000000001100100000000"
+                                                                                                                                                                                                 "111011111111111000100"
+                                                                                                                                                                                                 "101100010001010100111"
+                                                                                                                                                                                                 "101101101011000010100"
+                                                                                                                                                                                                 "100010000101010110110"
+                                                                                                                                                                                                 "010111101110110010101"
+                                                                                                                                                                                                 "000000001001010110110"
+                                                                                                                                                                                                 "111111101000100011111"
+                                                                                                                                                                                                 "100000101000001010100"
+                                                                                                                                                                                                 "101110101100100101100"
+                                                                                                                                                                                                 "101110100010010010110"
+                                                                                                                                                                                                 "101110101010100101001"
+                                                                                                                                                                                                 "100000101111110111001"
+                                                                                                                                                                                                 "111111101101001101111"},
+    /* 48*/ {BARCODE_QRCODE, UNICODE_MODE, 9, 1, -1, 8 << 8, {0, 0, ""}, "Μέρος #. α123", -1, 0, 25, 25, 0, "AIM ITS/04-023:2022 ECI 9 Example 1 with explicit mask 111; BWIPP uses mask 000", "111111100100101111111"
+                                                                                                                                                                                               "100000101101001000001"
+                                                                                                                                                                                               "101110101101101011101"
+                                                                                                                                                                                               "101110100101001011101"
+                                                                                                                                                                                               "101110101001001011101"
+                                                                                                                                                                                               "100000101000101000001"
+                                                                                                                                                                                               "111111101010101111111"
+                                                                                                                                                                                               "000000001110100000000"
+                                                                                                                                                                                               "110100110110101110110"
+                                                                                                                                                                                               "101100010001010100111"
+                                                                                                                                                                                               "111111111001010000110"
+                                                                                                                                                                                               "101011001100011111111"
+                                                                                                                                                                                               "010111101110110010101"
+                                                                                                                                                                                               "000000001011000100100"
+                                                                                                                                                                                               "111111101001101010110"
+                                                                                                                                                                                               "100000100000001010100"
+                                                                                                                                                                                               "101110100110110111110"
+                                                                                                                                                                                               "101110101011011011111"
+                                                                                                                                                                                               "101110100010100101001"
+                                                                                                                                                                                               "100000101101100101011"
+                                                                                                                                                                                               "111111101100000100110"},
+    /* 49*/ {BARCODE_QRCODE, UNICODE_MODE, 9, 1, -1, 1 << 8, {0, 0, ""}, "Μέρος #. α123", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 9 Example 1 **NOT SAME** explicit mask 000", "111111100100101111111"
+                                                                                                                                                                                  "100000100111001000001"
+                                                                                                                                                                                  "101110101100101011101"
+                                                                                                                                                                                  "101110100101001011101"
+                                                                                                                                                                                  "101110100011001011101"
+                                                                                                                                                                                  "100000100001101000001"
+                                                                                                                                                                                  "111111101010101111111"
+                                                                                                                                                                                  "000000001100100000000"
+                                                                                                                                                                                  "111011111111111000100"
+                                                                                                                                                                                  "101100010001010100111"
+                                                                                                                                                                                  "101101101011000010100"
+                                                                                                                                                                                  "100010000101010110110"
+                                                                                                                                                                                  "010111101110110010101"
+                                                                                                                                                                                  "000000001001010110110"
+                                                                                                                                                                                  "111111101000100011111"
+                                                                                                                                                                                  "100000101000001010100"
+                                                                                                                                                                                  "101110101100100101100"
+                                                                                                                                                                                  "101110100010010010110"
+                                                                                                                                                                                  "101110101010100101001"
+                                                                                                                                                                                  "100000101111110111001"
+                                                                                                                                                                                  "111111101101001101111"},
+    /* 50*/ {BARCODE_QRCODE, UNICODE_MODE, 10, 1, -1, -1, {0, 0, ""}, "דרכון", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 10 Example 1; BWIPP uses mask 000 instead of 101", "111111100000101111111"
+                                                                                                                                                                             "100000100010101000001"
+                                                                                                                                                                             "101110100011101011101"
+                                                                                                                                                                             "101110101010101011101"
+                                                                                                                                                                             "101110101100101011101"
+                                                                                                                                                                             "100000100101001000001"
+                                                                                                                                                                             "111111101010101111111"
+                                                                                                                                                                             "000000000000000000000"
+                                                                                                                                                                             "110001110001000011000"
+                                                                                                                                                                             "101110010001110011011"
+                                                                                                                                                                             "001110111110101100010"
+                                                                                                                                                                             "011100010001111000100"
+                                                                                                                                                                             "010100111101111110011"
+                                                                                                                                                                             "000000001100100111000"
+                                                                                                                                                                             "111111101111010011010"
+                                                                                                                                                                             "100000101100001000000"
+                                                                                                                                                                             "101110100001010010101"
+                                                                                                                                                                             "101110100101111101000"
+                                                                                                                                                                             "101110100001110011011"
+                                                                                                                                                                             "100000101111111010011"
+                                                                                                                                                                             "111111101110100011010"},
+    /* 51*/ {BARCODE_QRCODE, UNICODE_MODE, 10, 1, -1, 1 << 8, {0, 0, ""}, "דרכון", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 10 Example 1 **NOT SAME** explicit mask 000", "111111100101101111111"
+                                                                                                                                                                            "100000100111001000001"
+                                                                                                                                                                            "101110101101101011101"
+                                                                                                                                                                            "101110100101001011101"
+                                                                                                                                                                            "101110100010101011101"
+                                                                                                                                                                            "100000100000101000001"
+                                                                                                                                                                            "111111101010101111111"
+                                                                                                                                                                            "000000001101100000000"
+                                                                                                                                                                            "111011111111011000100"
+                                                                                                                                                                            "010001001110001100100"
+                                                                                                                                                                            "000000110000100010011"
+                                                                                                                                                                            "101001000100001101010"
+                                                                                                                                                                            "000001101000101011001"
+                                                                                                                                                                            "000000001001010010110"
+                                                                                                                                                                            "111111101001011101011"
+                                                                                                                                                                            "100000101011110111111"
+                                                                                                                                                                            "101110101111011100100"
+                                                                                                                                                                            "101110100000001000110"
+                                                                                                                                                                            "101110101100100110001"
+                                                                                                                                                                            "100000101010001111101"
+                                                                                                                                                                            "111111101000101101011"},
+    /* 52*/ {BARCODE_QRCODE, UNICODE_MODE, 10, 1, -1, -1, {0, 0, ""}, "מספר חלק: A20200715001", -1, 0, 25, 25, 0, "AIM ITS/04-023:2022 ECI 10 Example 2 **NOT SAME** different encodation; BWIPP uses mask 000 instead of 100", "1111111011101100001111111"
+                                                                                                                                                                                                                                "1000001011100001001000001"
+                                                                                                                                                                                                                                "1011101010110001001011101"
+                                                                                                                                                                                                                                "1011101011010000001011101"
+                                                                                                                                                                                                                                "1011101000000110001011101"
+                                                                                                                                                                                                                                "1000001010011010001000001"
+                                                                                                                                                                                                                                "1111111010101010101111111"
+                                                                                                                                                                                                                                "0000000001001001100000000"
+                                                                                                                                                                                                                                "1100111000010110000101111"
+                                                                                                                                                                                                                                "1011100011101011010011100"
+                                                                                                                                                                                                                                "0001001000011110110110001"
+                                                                                                                                                                                                                                "0111110010110101001111111"
+                                                                                                                                                                                                                                "1001111010101101000111010"
+                                                                                                                                                                                                                                "1001010100000110100001110"
+                                                                                                                                                                                                                                "0011011100100000110010011"
+                                                                                                                                                                                                                                "0001110001101010111110110"
+                                                                                                                                                                                                                                "1111011000010110111110001"
+                                                                                                                                                                                                                                "0000000010101000100011101"
+                                                                                                                                                                                                                                "1111111001111111101010000"
+                                                                                                                                                                                                                                "1000001010010101100011011"
+                                                                                                                                                                                                                                "1011101010001100111110000"
+                                                                                                                                                                                                                                "1011101001000111001000001"
+                                                                                                                                                                                                                                "1011101001000001110101010"
+                                                                                                                                                                                                                                "1000001011001010100011101"
+                                                                                                                                                                                                                                "1111111011010110001000011"},
+    /* 53*/ {BARCODE_QRCODE, UNICODE_MODE, 10, 1, -1, 1 << 8, {0, 0, ""}, "מספר חלק: A20200715001", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 10 Example 2 **NOT SAME** different encodation", "1111111001001000101111111"
+                                                                                                                                                                                                "1000001000111010001000001"
+                                                                                                                                                                                                "1011101011101010001011101"
+                                                                                                                                                                                                "1011101001110100101011101"
+                                                                                                                                                                                                "1011101000100010101011101"
+                                                                                                                                                                                                "1000001001000001001000001"
+                                                                                                                                                                                                "1111111010101010101111111"
+                                                                                                                                                                                                "0000000011101101000000000"
+                                                                                                                                                                                                "1110111110110010111000100"
+                                                                                                                                                                                                "0000110000110000001000111"
+                                                                                                                                                                                                "1010011011000101101101010"
+                                                                                                                                                                                                "0011010110010001101011011"
+                                                                                                                                                                                                "1101011110001001100011110"
+                                                                                                                                                                                                "0010000111011101111010101"
+                                                                                                                                                                                                "1000001111111011101001000"
+                                                                                                                                                                                                "0101010101001110011010010"
+                                                                                                                                                                                                "1011111100110010111110101"
+                                                                                                                                                                                                "0000000011110011100010110"
+                                                                                                                                                                                                "1111111010100100101011011"
+                                                                                                                                                                                                "1000001010110001100011111"
+                                                                                                                                                                                                "1011101010101000111110100"
+                                                                                                                                                                                                "1011101000011100010011010"
+                                                                                                                                                                                                "1011101010011010101110001"
+                                                                                                                                                                                                "1000001011101110000111001"
+                                                                                                                                                                                                "1111111011110010101100111"},
+    /* 54*/ {BARCODE_QRCODE, UNICODE_MODE, 11, 1, -1, -1, {0, 0, ""}, "Amerika Birleşik Devletleri", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 11 Example 1", "1111111000111100101111111"
+                                                                                                                                                               "1000001001101101001000001"
+                                                                                                                                                               "1011101000001000101011101"
+                                                                                                                                                               "1011101010000010001011101"
+                                                                                                                                                               "1011101011001001001011101"
+                                                                                                                                                               "1000001000011011001000001"
+                                                                                                                                                               "1111111010101010101111111"
+                                                                                                                                                               "0000000000110001100000000"
+                                                                                                                                                               "1100011101001011000011000"
+                                                                                                                                                               "1010000001011011001011111"
+                                                                                                                                                               "0101111100100110111011101"
+                                                                                                                                                               "0011010001010001101001101"
+                                                                                                                                                               "1000001111010100011010101"
+                                                                                                                                                               "1110010010000010100001010"
+                                                                                                                                                               "1001101010001111011011100"
+                                                                                                                                                               "1001000001110001000111111"
+                                                                                                                                                               "1011111100001111111110001"
+                                                                                                                                                               "0000000010100000100011001"
+                                                                                                                                                               "1111111011001001101010001"
+                                                                                                                                                               "1000001010110101100010010"
+                                                                                                                                                               "1011101001101010111111100"
+                                                                                                                                                               "1011101000100010000101101"
+                                                                                                                                                               "1011101001000110011011101"
+                                                                                                                                                               "1000001010110000111010110"
+                                                                                                                                                               "1111111010110101100010101"},
+    /* 55*/ {BARCODE_QRCODE, UNICODE_MODE, 11, 1, -1, -1, {0, 0, ""}, "Biniş kartı #120921039", -1, 0, 25, 25, 0, "AIM ITS/04-023:2022 ECI 11 Example 2 **NOT SAME** different encodation; BWIPP same encodation as Zint but uses mask 101 instead of 111", "1111111000100110101111111"
+                                                                                                                                                                                                                                                            "1000001011100110001000001"
+                                                                                                                                                                                                                                                            "1011101010000001001011101"
+                                                                                                                                                                                                                                                            "1011101001001011001011101"
+                                                                                                                                                                                                                                                            "1011101011101110101011101"
+                                                                                                                                                                                                                                                            "1000001010101101001000001"
+                                                                                                                                                                                                                                                            "1111111010101010101111111"
+                                                                                                                                                                                                                                                            "0000000010110000100000000"
+                                                                                                                                                                                                                                                            "1101001100011100101110110"
+                                                                                                                                                                                                                                                            "0011000111011101000100011"
+                                                                                                                                                                                                                                                            "1111101100011000111100101"
+                                                                                                                                                                                                                                                            "0101010011111101011011100"
+                                                                                                                                                                                                                                                            "0001011110110010001101111"
+                                                                                                                                                                                                                                                            "0101100100010100111010100"
+                                                                                                                                                                                                                                                            "1011001100010110101010000"
+                                                                                                                                                                                                                                                            "0111000011010000001000110"
+                                                                                                                                                                                                                                                            "1110001000101100111110101"
+                                                                                                                                                                                                                                                            "0000000010101111100010000"
+                                                                                                                                                                                                                                                            "1111111010011010101010011"
+                                                                                                                                                                                                                                                            "1000001001001011100011001"
+                                                                                                                                                                                                                                                            "1011101000100000111111110"
+                                                                                                                                                                                                                                                            "1011101010010011100100110"
+                                                                                                                                                                                                                                                            "1011101000100000001111101"
+                                                                                                                                                                                                                                                            "1000001011100010011100111"
+                                                                                                                                                                                                                                                            "1111111010001001010010011"},
+    /* 56*/ {BARCODE_QRCODE, UNICODE_MODE, 11, 1, -1, 6 << 8, {0, 0, ""}, "Biniş kartı #120921039", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 11 Example 2 **NOT SAME** different encodation", "1111111001110011101111111"
+                                                                                                                                                                                                "1000001000011111101000001"
+                                                                                                                                                                                                "1011101001110000101011101"
+                                                                                                                                                                                                "1011101010110100101011101"
+                                                                                                                                                                                                "1011101010101001101011101"
+                                                                                                                                                                                                "1000001001100010001000001"
+                                                                                                                                                                                                "1111111010101010101111111"
+                                                                                                                                                                                                "0000000001001001000000000"
+                                                                                                                                                                                                "1100011101101101000011000"
+                                                                                                                                                                                                "1100110000100010111011100"
+                                                                                                                                                                                                "1000101011011111111011101"
+                                                                                                                                                                                                "1010010100110010010100101"
+                                                                                                                                                                                                "0100001011100111011000101"
+                                                                                                                                                                                                "1100010101101101000011011"
+                                                                                                                                                                                                "1010111101100111011011110"
+                                                                                                                                                                                                "1000110100101111110111001"
+                                                                                                                                                                                                "1001001111101011111111101"
+                                                                                                                                                                                                "0000000011100000100011001"
+                                                                                                                                                                                                "1111111011001111101011001"
+                                                                                                                                                                                                "1000001010110010100010110"
+                                                                                                                                                                                                "1011101001010001111110000"
+                                                                                                                                                                                                "1011101001101100011011001"
+                                                                                                                                                                                                "1011101001100111001000101"
+                                                                                                                                                                                                "1000001010101101010011110"
+                                                                                                                                                                                                "1111111011011100000111001"},
+    /* 57*/ {BARCODE_QRCODE, UNICODE_MODE, 12, 1, -1, -1, {0, 0, ""}, "Kūrybiškumą", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 12 Example 1; BWIPP uses mask 111 instead of 100", "111111101111101111111"
+                                                                                                                                                                                   "100000101010101000001"
+                                                                                                                                                                                   "101110101000001011101"
+                                                                                                                                                                                   "101110101111001011101"
+                                                                                                                                                                                   "101110100000101011101"
+                                                                                                                                                                                   "100000101101001000001"
+                                                                                                                                                                                   "111111101010101111111"
+                                                                                                                                                                                   "000000000111100000000"
+                                                                                                                                                                                   "110011100101000101111"
+                                                                                                                                                                                   "100110001010110101100"
+                                                                                                                                                                                   "010011100011011101001"
+                                                                                                                                                                                   "000000001101001101100"
+                                                                                                                                                                                   "001101101010110101011"
+                                                                                                                                                                                   "000000001101101010011"
+                                                                                                                                                                                   "111111100101001110110"
+                                                                                                                                                                                   "100000101100101100100"
+                                                                                                                                                                                   "101110101110000100000"
+                                                                                                                                                                                   "101110100111101101111"
+                                                                                                                                                                                   "101110100100111100100"
+                                                                                                                                                                                   "100000101011110001011"
+                                                                                                                                                                                   "111111101001101100001"},
+    /* 58*/ {BARCODE_QRCODE, UNICODE_MODE, 12, 1, -1, 8 << 8, {0, 0, ""}, "Kūrybiškumą", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 12 Example 1 **NOT SAME** explicit mask 111", "111111100101101111111"
+                                                                                                                                                                                  "100000101101001000001"
+                                                                                                                                                                                  "101110101100101011101"
+                                                                                                                                                                                  "101110100101001011101"
+                                                                                                                                                                                  "101110101000101011101"
+                                                                                                                                                                                  "100000101001101000001"
+                                                                                                                                                                                  "111111101010101111111"
+                                                                                                                                                                                  "000000001111100000000"
+                                                                                                                                                                                  "110100110110001110110"
+                                                                                                                                                                                  "001011000111011000001"
+                                                                                                                                                                                  "101100111100100010110"
+                                                                                                                                                                                  "011011010110010110111"
+                                                                                                                                                                                  "011111111000100111001"
+                                                                                                                                                                                  "000000001010010101100"
+                                                                                                                                                                                  "111111101001101010010"
+                                                                                                                                                                                  "100000100110111110110"
+                                                                                                                                                                                  "101110100110000100000"
+                                                                                                                                                                                  "101110101011001001011"
+                                                                                                                                                                                  "101110100001010001001"
+                                                                                                                                                                                  "100000101011110001011"
+                                                                                                                                                                                  "111111101010110111010"},
+    /* 59*/ {BARCODE_QRCODE, UNICODE_MODE, 13, 1, -1, -1, {0, 0, ""}, "บาร๋แค่ด", -1, 0, 25, 25, 0, "AIM ITS/04-023:2022 ECI 13 Example 1; BWIPP uses mask 001 instead of 111", "111111100010101111111"
+                                                                                                                                                                              "100000101010101000001"
+                                                                                                                                                                              "101110101011001011101"
+                                                                                                                                                                              "101110100000101011101"
+                                                                                                                                                                              "101110101111101011101"
+                                                                                                                                                                              "100000101110001000001"
+                                                                                                                                                                              "111111101010101111111"
+                                                                                                                                                                              "000000001000000000000"
+                                                                                                                                                                              "110100110011101110110"
+                                                                                                                                                                              "011110001111001101110"
+                                                                                                                                                                              "101100111101010101010"
+                                                                                                                                                                              "001101001100110110111"
+                                                                                                                                                                              "010011101111001000001"
+                                                                                                                                                                              "000000001100001010100"
+                                                                                                                                                                              "111111101111111010110"
+                                                                                                                                                                              "100000100110000111000"
+                                                                                                                                                                              "101110100010111110000"
+                                                                                                                                                                              "101110101000011011111"
+                                                                                                                                                                              "101110100111001000101"
+                                                                                                                                                                              "100000101011100101011"
+                                                                                                                                                                              "111111101010000100010"},
+    /* 60*/ {BARCODE_QRCODE, UNICODE_MODE, 13, 1, -1, 2 << 8, {0, 0, ""}, "บาร๋แค่ด", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 13 Example 1 **NOT SAME** explicit mask 001", "111111101111101111111"
+                                                                                                                                                                             "100000101101101000001"
+                                                                                                                                                                             "101110100111001011101"
+                                                                                                                                                                             "101110100101101011101"
+                                                                                                                                                                             "101110101000101011101"
+                                                                                                                                                                             "100000101010001000001"
+                                                                                                                                                                             "111111101010101111111"
+                                                                                                                                                                             "000000001111000000000"
+                                                                                                                                                                             "111001101111111110011"
+                                                                                                                                                                             "001011011010011000100"
+                                                                                                                                                                             "101011111010010010010"
+                                                                                                                                                                             "010001010000101010100"
+                                                                                                                                                                             "000110111010011101011"
+                                                                                                                                                                             "000000001011001101100"
+                                                                                                                                                                             "111111100011100110101"
+                                                                                                                                                                             "100000101011010010010"
+                                                                                                                                                                             "101110100101111001000"
+                                                                                                                                                                             "101110100100000111100"
+                                                                                                                                                                             "101110101010011101111"
+                                                                                                                                                                             "100000101100100010011"
+                                                                                                                                                                             "111111101110011000001"},
+    /* 61*/ {BARCODE_QRCODE, UNICODE_MODE, 15, 1, -1, -1, {0, 0, ""}, "uzņēmums", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 15 Example 1; BWIPP uses mask 011 instead of 111", "111111100010101111111"
+                                                                                                                                                                                "100000101010101000001"
+                                                                                                                                                                                "101110101011001011101"
+                                                                                                                                                                                "101110100000101011101"
+                                                                                                                                                                                "101110101111101011101"
+                                                                                                                                                                                "100000101110001000001"
+                                                                                                                                                                                "111111101010101111111"
+                                                                                                                                                                                "000000001000000000000"
+                                                                                                                                                                                "110100110011101110110"
+                                                                                                                                                                                "110000001011000000010"
+                                                                                                                                                                                "000011101101010101010"
+                                                                                                                                                                                "011011001110100011011"
+                                                                                                                                                                                "000010110011011111101"
+                                                                                                                                                                                "000000001100010010000"
+                                                                                                                                                                                "111111101101111100010"
+                                                                                                                                                                                "100000100000010111101"
+                                                                                                                                                                                "101110100110100100000"
+                                                                                                                                                                                "101110101110011011111"
+                                                                                                                                                                                "101110100111001111001"
+                                                                                                                                                                                "100000101111100101011"
+                                                                                                                                                                                "111111101000000101010"},
+    /* 62*/ {BARCODE_QRCODE, UNICODE_MODE, 15, 1, -1, 4 << 8, {0, 0, ""}, "uzņēmums", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 15 Example 1 **NOT SAME** explicit mask 011", "111111101100101111111"
+                                                                                                                                                                               "100000100100101000001"
+                                                                                                                                                                               "101110101010101011101"
+                                                                                                                                                                               "101110101001001011101"
+                                                                                                                                                                               "101110101110001011101"
+                                                                                                                                                                               "100000100000001000001"
+                                                                                                                                                                               "111111101010101111111"
+                                                                                                                                                                               "000000000110000000000"
+                                                                                                                                                                               "111100101010010011101"
+                                                                                                                                                                               "000001011010110001100"
+                                                                                                                                                                               "110010111100100100100"
+                                                                                                                                                                               "010101000000101101010"
+                                                                                                                                                                               "001100111101010001100"
+                                                                                                                                                                               "000000001010011100001"
+                                                                                                                                                                               "111111100100001101100"
+                                                                                                                                                                               "100000100001100110011"
+                                                                                                                                                                               "101110100111010101110"
+                                                                                                                                                                               "101110101000010101110"
+                                                                                                                                                                               "101110101001000001000"
+                                                                                                                                                                               "100000101001101011010"
+                                                                                                                                                                               "111111101001110100100"},
+    /* 63*/ {BARCODE_QRCODE, UNICODE_MODE, 16, 1, -1, -1, {0, 0, ""}, "ṁórṡáċ", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 16 Example 1; BWIPP uses mask 001 instead of 111", "111111100010101111111"
+                                                                                                                                                                              "100000101010101000001"
+                                                                                                                                                                              "101110101011001011101"
+                                                                                                                                                                              "101110100000101011101"
+                                                                                                                                                                              "101110101111101011101"
+                                                                                                                                                                              "100000101110001000001"
+                                                                                                                                                                              "111111101010101111111"
+                                                                                                                                                                              "000000001000000000000"
+                                                                                                                                                                              "110100110011101110110"
+                                                                                                                                                                              "000100000111010001111"
+                                                                                                                                                                              "011010111101011101001"
+                                                                                                                                                                              "001001001000111111011"
+                                                                                                                                                                              "110111110011001001101"
+                                                                                                                                                                              "000000001100011010100"
+                                                                                                                                                                              "111111101001101010010"
+                                                                                                                                                                              "100000100010001111010"
+                                                                                                                                                                              "101110100100111111011"
+                                                                                                                                                                              "101110101000011011001"
+                                                                                                                                                                              "101110100111011101001"
+                                                                                                                                                                              "100000101101100001011"
+                                                                                                                                                                              "111111101010010001010"},
+    /* 64*/ {BARCODE_QRCODE, UNICODE_MODE, 16, 1, -1, 2 << 8, {0, 0, ""}, "ṁórṡáċ", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 16 Example 1 **NOT SAME** explicit mask 001", "111111101111101111111"
+                                                                                                                                                                             "100000101101101000001"
+                                                                                                                                                                             "101110100111001011101"
+                                                                                                                                                                             "101110100101101011101"
+                                                                                                                                                                             "101110101000101011101"
+                                                                                                                                                                             "100000101010001000001"
+                                                                                                                                                                             "111111101010101111111"
+                                                                                                                                                                             "000000001111000000000"
+                                                                                                                                                                             "111001101111111110011"
+                                                                                                                                                                             "010001010010000100101"
+                                                                                                                                                                             "011101111010011010001"
+                                                                                                                                                                             "010101010100100011000"
+                                                                                                                                                                             "100010100110011100111"
+                                                                                                                                                                             "000000001011011101100"
+                                                                                                                                                                             "111111100101110110001"
+                                                                                                                                                                             "100000101111011010000"
+                                                                                                                                                                             "101110100011111000011"
+                                                                                                                                                                             "101110100100000111010"
+                                                                                                                                                                             "101110101010001000011"
+                                                                                                                                                                             "100000101010100110011"
+                                                                                                                                                                             "111111101110001101001"},
+    /* 65*/ {BARCODE_QRCODE, UNICODE_MODE, 17, 1, -1, -1, {0, 0, ""}, "Price: €13.50", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 17 Example 1", "111111100100101111111"
+                                                                                                                                                 "100000101101001000001"
+                                                                                                                                                 "101110101101101011101"
+                                                                                                                                                 "101110100101001011101"
+                                                                                                                                                 "101110101000101011101"
+                                                                                                                                                 "100000101000001000001"
+                                                                                                                                                 "111111101010101111111"
+                                                                                                                                                 "000000001110100000000"
+                                                                                                                                                 "110100110111101110110"
+                                                                                                                                                 "100010000000010110000"
+                                                                                                                                                 "100010101001110011100"
+                                                                                                                                                 "101110010101111010011"
+                                                                                                                                                 "011001111010101010101"
+                                                                                                                                                 "000000001101101010000"
+                                                                                                                                                 "111111101000001110010"
+                                                                                                                                                 "100000100111100111000"
+                                                                                                                                                 "101110100110111100011"
+                                                                                                                                                 "101110101011111011001"
+                                                                                                                                                 "101110100100110010001"
+                                                                                                                                                 "100000101000100101111"
+                                                                                                                                                 "111111101101110110110"},
+    /* 66*/ {BARCODE_QRCODE, UNICODE_MODE, 18, 1, -1, -1, {0, 0, ""}, "Te słowa są głębokie", -1, 0, 25, 25, 0, "AIM ITS/04-023:2022 ECI 18 Example 1; BWIPP uses mask 001 instead of 100", "1111111010000111001111111"
+                                                                                                                                                                                            "1000001010011000001000001"
+                                                                                                                                                                                            "1011101011001100001011101"
+                                                                                                                                                                                            "1011101011101111001011101"
+                                                                                                                                                                                            "1011101001101100101011101"
+                                                                                                                                                                                            "1000001011100001101000001"
+                                                                                                                                                                                            "1111111010101010101111111"
+                                                                                                                                                                                            "0000000000110100000000000"
+                                                                                                                                                                                            "1100111000101011100101111"
+                                                                                                                                                                                            "0001100010000101011111001"
+                                                                                                                                                                                            "1010101111100111010011000"
+                                                                                                                                                                                            "1010100011001100111100100"
+                                                                                                                                                                                            "1101011110010111101001011"
+                                                                                                                                                                                            "1001100100101101101010001"
+                                                                                                                                                                                            "0011101111111111100111000"
+                                                                                                                                                                                            "0011100111110000001101100"
+                                                                                                                                                                                            "1100101100101100111110001"
+                                                                                                                                                                                            "0000000011100100100011001"
+                                                                                                                                                                                            "1111111000100001101010000"
+                                                                                                                                                                                            "1000001010001001100011111"
+                                                                                                                                                                                            "1011101011010110111111101"
+                                                                                                                                                                                            "1011101001101010101000111"
+                                                                                                                                                                                            "1011101000011111101110010"
+                                                                                                                                                                                            "1000001011110101011011101"
+                                                                                                                                                                                            "1111111010001100000011111"},
+    /* 67*/ {BARCODE_QRCODE, UNICODE_MODE, 18, 1, -1, 2 << 8, {0, 0, ""}, "Te słowa są głębokie", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 18 Example 1 **NOT SAME** explicit mask 001", "1111111011110110101111111"
+                                                                                                                                                                                           "1000001010010110001000001"
+                                                                                                                                                                                           "1011101001000010001011101"
+                                                                                                                                                                                           "1011101000011110101011101"
+                                                                                                                                                                                           "1011101010011101001011101"
+                                                                                                                                                                                           "1000001011101111101000001"
+                                                                                                                                                                                           "1111111010101010101111111"
+                                                                                                                                                                                           "0000000011000101100000000"
+                                                                                                                                                                                           "1110011011011010011110011"
+                                                                                                                                                                                           "1111100100001011010001000"
+                                                                                                                                                                                           "0100101001101001011101001"
+                                                                                                                                                                                           "1011010010111101001101010"
+                                                                                                                                                                                           "1100101111100110011000101"
+                                                                                                                                                                                           "0111100010100011100100000"
+                                                                                                                                                                                           "1101101001110001101001001"
+                                                                                                                                                                                           "0010010110000001111100010"
+                                                                                                                                                                                           "1101011101011101111111111"
+                                                                                                                                                                                           "0000000011101010100011000"
+                                                                                                                                                                                           "1111111000101111101010001"
+                                                                                                                                                                                           "1000001011111000100010001"
+                                                                                                                                                                                           "1011101000100111111110011"
+                                                                                                                                                                                           "1011101001100100100110110"
+                                                                                                                                                                                           "1011101010010001100000011"
+                                                                                                                                                                                           "1000001010000100101010011"
+                                                                                                                                                                                           "1111111011111101110010001"},
+    /* 68*/ {BARCODE_QRCODE, UNICODE_MODE, 20, 1, -1, -1, {0, 0, ""}, "バーコード", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 20 Example 1; BWIPP uses mask 011 instead of 111", "111111100010101111111"
+                                                                                                                                                                                  "100000101010101000001"
+                                                                                                                                                                                  "101110101011001011101"
+                                                                                                                                                                                  "101110100000101011101"
+                                                                                                                                                                                  "101110101111101011101"
+                                                                                                                                                                                  "100000101110001000001"
+                                                                                                                                                                                  "111111101010101111111"
+                                                                                                                                                                                  "000000001000000000000"
+                                                                                                                                                                                  "110100110011101110110"
+                                                                                                                                                                                  "101011011011011001000"
+                                                                                                                                                                                  "110011111001000000101"
+                                                                                                                                                                                  "000111011100111101111"
+                                                                                                                                                                                  "100111110011001011101"
+                                                                                                                                                                                  "000000001000011110000"
+                                                                                                                                                                                  "111111101101110110001"
+                                                                                                                                                                                  "100000100110000111110"
+                                                                                                                                                                                  "101110100110111000101"
+                                                                                                                                                                                  "101110101000011010001"
+                                                                                                                                                                                  "101110100011001010101"
+                                                                                                                                                                                  "100000101011100110011"
+                                                                                                                                                                                  "111111101010000101010"},
+    /* 69*/ {BARCODE_QRCODE, UNICODE_MODE, 20, 1, -1, 4 << 8, {0, 0, ""}, "バーコード", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 20 Example 1 **NOT SAME** explicit mask 011", "111111101100101111111"
+                                                                                                                                                                                 "100000100100101000001"
+                                                                                                                                                                                 "101110101010101011101"
+                                                                                                                                                                                 "101110101001001011101"
+                                                                                                                                                                                 "101110101110001011101"
+                                                                                                                                                                                 "100000100000001000001"
+                                                                                                                                                                                 "111111101010101111111"
+                                                                                                                                                                                 "000000000110000000000"
+                                                                                                                                                                                 "111100101010010011101"
+                                                                                                                                                                                 "011010001010101000110"
+                                                                                                                                                                                 "000010101000110001011"
+                                                                                                                                                                                 "001001010010110011110"
+                                                                                                                                                                                 "101001111101000101100"
+                                                                                                                                                                                 "000000001110010000001"
+                                                                                                                                                                                 "111111100100000111111"
+                                                                                                                                                                                 "100000100111110110000"
+                                                                                                                                                                                 "101110100111001001011"
+                                                                                                                                                                                 "101110101110010100000"
+                                                                                                                                                                                 "101110101101000100100"
+                                                                                                                                                                                 "100000101101101000010"
+                                                                                                                                                                                 "111111101011110100100"},
+    /* 70*/ {BARCODE_QRCODE, UNICODE_MODE, 20, 1, -1, -1, {0, 0, ""}, "東京都", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 20 Example 2; BWIPP uses mask 000 instead of 100", "111111101111101111111"
+                                                                                                                                                                              "100000101010101000001"
+                                                                                                                                                                              "101110101000001011101"
+                                                                                                                                                                              "101110101111001011101"
+                                                                                                                                                                              "101110100000101011101"
+                                                                                                                                                                              "100000101101001000001"
+                                                                                                                                                                              "111111101010101111111"
+                                                                                                                                                                              "000000000111100000000"
+                                                                                                                                                                              "110011100101000101111"
+                                                                                                                                                                              "011110011101100001100"
+                                                                                                                                                                              "111011100111001111100"
+                                                                                                                                                                              "101110011100011110100"
+                                                                                                                                                                              "010010111000111000011"
+                                                                                                                                                                              "000000001100111011111"
+                                                                                                                                                                              "111111100000110011101"
+                                                                                                                                                                              "100000101001100101000"
+                                                                                                                                                                              "101110101101001101101"
+                                                                                                                                                                              "101110100011100111001"
+                                                                                                                                                                              "101110100101001100100"
+                                                                                                                                                                              "100000101010011010011"
+                                                                                                                                                                              "111111101100111011001"},
+    /* 71*/ {BARCODE_QRCODE, UNICODE_MODE, 20, 1, -1, 1 << 8, {0, 0, ""}, "東京都", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 20 Example 2 **NOT SAME** explicit mask 000", "111111100101101111111"
+                                                                                                                                                                             "100000100111001000001"
+                                                                                                                                                                             "101110101101101011101"
+                                                                                                                                                                             "101110100101001011101"
+                                                                                                                                                                             "101110100010101011101"
+                                                                                                                                                                             "100000100000101000001"
+                                                                                                                                                                             "111111101010101111111"
+                                                                                                                                                                             "000000001101100000000"
+                                                                                                                                                                             "111011111111011000100"
+                                                                                                                                                                             "110011010000001100001"
+                                                                                                                                                                             "010110101010100010001"
+                                                                                                                                                                             "111100001110001100110"
+                                                                                                                                                                             "000000101010101010001"
+                                                                                                                                                                             "000000001001010110010"
+                                                                                                                                                                             "111111101101011110000"
+                                                                                                                                                                             "100000101011110111010"
+                                                                                                                                                                             "101110101111011111111"
+                                                                                                                                                                             "101110100110001010100"
+                                                                                                                                                                             "101110101000100001001"
+                                                                                                                                                                             "100000101000001000001"
+                                                                                                                                                                             "111111101110101001011"},
+    /* 72*/ {BARCODE_QRCODE, UNICODE_MODE, 21, 1, -1, -1, {0, 0, ""}, "Študentska št. 2198390", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 21 Example 1 **NOT SAME** different encodation", "1111111010000110001111111"
+                                                                                                                                                                                            "1000001010011110101000001"
+                                                                                                                                                                                            "1011101011001111101011101"
+                                                                                                                                                                                            "1011101011101011101011101"
+                                                                                                                                                                                            "1011101001101010001011101"
+                                                                                                                                                                                            "1000001011100100001000001"
+                                                                                                                                                                                            "1111111010101010101111111"
+                                                                                                                                                                                            "0000000000110110100000000"
+                                                                                                                                                                                            "1100111000101010000101111"
+                                                                                                                                                                                            "1000000010000001110111000"
+                                                                                                                                                                                            "1001011011100010100110011"
+                                                                                                                                                                                            "0110100101001010111100110"
+                                                                                                                                                                                            "1111111100010110000110000"
+                                                                                                                                                                                            "1011000111101000110011010"
+                                                                                                                                                                                            "0000001011011011000110001"
+                                                                                                                                                                                            "0011000100010000011100110"
+                                                                                                                                                                                            "1101101101001110111111001"
+                                                                                                                                                                                            "0000000011000110100011001"
+                                                                                                                                                                                            "1111111001100000101011000"
+                                                                                                                                                                                            "1000001011001001100010100"
+                                                                                                                                                                                            "1011101011110111111110011"
+                                                                                                                                                                                            "1011101001001011001101011"
+                                                                                                                                                                                            "1011101001011111000111010"
+                                                                                                                                                                                            "1000001010010101110010101"
+                                                                                                                                                                                            "1111111010101100000011011"},
+    /* 73*/ {BARCODE_QRCODE, UNICODE_MODE, 22, 1, -1, -1, {0, 0, ""}, "Россия", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 22 Example 1", "111111100010101111111"
+                                                                                                                                          "100000101010101000001"
+                                                                                                                                          "101110101011001011101"
+                                                                                                                                          "101110100000101011101"
+                                                                                                                                          "101110101111101011101"
+                                                                                                                                          "100000101110001000001"
+                                                                                                                                          "111111101010101111111"
+                                                                                                                                          "000000001000000000000"
+                                                                                                                                          "110100110011101110110"
+                                                                                                                                          "101000001111010010111"
+                                                                                                                                          "011101110101011111101"
+                                                                                                                                          "110011010010111010011"
+                                                                                                                                          "101010101111001100101"
+                                                                                                                                          "000000001000011110100"
+                                                                                                                                          "111111101001101001010"
+                                                                                                                                          "100000100010001110111"
+                                                                                                                                          "101110100000111110001"
+                                                                                                                                          "101110101010011001101"
+                                                                                                                                          "101110100011011011001"
+                                                                                                                                          "100000101001100001011"
+                                                                                                                                          "111111101100010100110"},
+    /* 74*/ {BARCODE_QRCODE, UNICODE_MODE, 22, 1, -1, -1, {0, 0, ""}, "Монголулс", -1, 0, 25, 25, 0, "AIM ITS/04-023:2022 ECI 22 Example 2; BWIPP uses mask 000 instead of 100", "111111101111101111111"
+                                                                                                                                                                                 "100000101010101000001"
+                                                                                                                                                                                 "101110101000001011101"
+                                                                                                                                                                                 "101110101111001011101"
+                                                                                                                                                                                 "101110100000101011101"
+                                                                                                                                                                                 "100000101101001000001"
+                                                                                                                                                                                 "111111101010101111111"
+                                                                                                                                                                                 "000000000111100000000"
+                                                                                                                                                                                 "110011100101000101111"
+                                                                                                                                                                                 "110010000001100111001"
+                                                                                                                                                                                 "101001110101011101001"
+                                                                                                                                                                                 "011011001100000100100"
+                                                                                                                                                                                 "110110111100100110111"
+                                                                                                                                                                                 "000000001100100011011"
+                                                                                                                                                                                 "111111100000101001110"
+                                                                                                                                                                                 "100000101011101100101"
+                                                                                                                                                                                 "101110101111000110001"
+                                                                                                                                                                                 "101110100110100111001"
+                                                                                                                                                                                 "101110100101011111100"
+                                                                                                                                                                                 "100000101001000100111"
+                                                                                                                                                                                 "111111101000101111101"},
+    /* 75*/ {BARCODE_QRCODE, UNICODE_MODE, 22, 1, -1, 1 << 8, {0, 0, ""}, "Монголулс", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 22 Example 2 **NOT SAME** explicit mask 000", "111111100101101111111"
+                                                                                                                                                                                "100000100111001000001"
+                                                                                                                                                                                "101110101101101011101"
+                                                                                                                                                                                "101110100101001011101"
+                                                                                                                                                                                "101110100010101011101"
+                                                                                                                                                                                "100000100000101000001"
+                                                                                                                                                                                "111111101010101111111"
+                                                                                                                                                                                "000000001101100000000"
+                                                                                                                                                                                "111011111111011000100"
+                                                                                                                                                                                "011111001100001010100"
+                                                                                                                                                                                "000100111000110000100"
+                                                                                                                                                                                "001001011110010110110"
+                                                                                                                                                                                "100100101110110100101"
+                                                                                                                                                                                "000000001001001110110"
+                                                                                                                                                                                "111111101101000100011"
+                                                                                                                                                                                "100000101001111110111"
+                                                                                                                                                                                "101110101101010100011"
+                                                                                                                                                                                "101110100011001010100"
+                                                                                                                                                                                "101110101000110010001"
+                                                                                                                                                                                "100000101011010110101"
+                                                                                                                                                                                "111111101010111101111"},
+    /* 76*/ {BARCODE_QRCODE, UNICODE_MODE, 23, 1, -1, -1, {0, 0, ""}, "bœuf", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 23 Example 1; BWIPP uses mask 000 instead of 111", "111111100010101111111"
+                                                                                                                                                                            "100000101010101000001"
+                                                                                                                                                                            "101110101011001011101"
+                                                                                                                                                                            "101110100000101011101"
+                                                                                                                                                                            "101110101111101011101"
+                                                                                                                                                                            "100000101110001000001"
+                                                                                                                                                                            "111111101010101111111"
+                                                                                                                                                                            "000000001000000000000"
+                                                                                                                                                                            "110100110011101110110"
+                                                                                                                                                                            "010001001111010100010"
+                                                                                                                                                                            "010001100011001110001"
+                                                                                                                                                                            "111111001100111110011"
+                                                                                                                                                                            "010100110101011100001"
+                                                                                                                                                                            "000000001010011111100"
+                                                                                                                                                                            "111111101011101010110"
+                                                                                                                                                                            "100000100100001100101"
+                                                                                                                                                                            "101110100110111000101"
+                                                                                                                                                                            "101110101100011111001"
+                                                                                                                                                                            "101110100101011111001"
+                                                                                                                                                                            "100000101001100100011"
+                                                                                                                                                                            "111111101000010110110"},
+    /* 77*/ {BARCODE_QRCODE, UNICODE_MODE, 23, 1, -1, 1 << 8, {0, 0, ""}, "bœuf", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 23 Example 1 ** NOT SAME** explicit mask 000", "111111100010101111111"
+                                                                                                                                                                            "100000100000101000001"
+                                                                                                                                                                            "101110101010001011101"
+                                                                                                                                                                            "101110100000101011101"
+                                                                                                                                                                            "101110100101101011101"
+                                                                                                                                                                            "100000100111001000001"
+                                                                                                                                                                            "111111101010101111111"
+                                                                                                                                                                            "000000001010000000000"
+                                                                                                                                                                            "111011111010111000100"
+                                                                                                                                                                            "010001001111010100010"
+                                                                                                                                                                            "000011110001011100011"
+                                                                                                                                                                            "110110000101110111010"
+                                                                                                                                                                            "010100110101011100001"
+                                                                                                                                                                            "000000001000001101110"
+                                                                                                                                                                            "111111101010100011111"
+                                                                                                                                                                            "100000101100001100101"
+                                                                                                                                                                            "101110101100101010111"
+                                                                                                                                                                            "101110100101010110000"
+                                                                                                                                                                            "101110101101011111001"
+                                                                                                                                                                            "100000101011110110001"
+                                                                                                                                                                            "111111101001011111111"},
+    /* 78*/ {BARCODE_QRCODE, UNICODE_MODE, 24, 1, -1, -1, {0, 0, ""}, "جواز السفر", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 24 Example 1", "111111100010101111111"
+                                                                                                                                              "100000100000101000001"
+                                                                                                                                              "101110101010001011101"
+                                                                                                                                              "101110100000101011101"
+                                                                                                                                              "101110100101101011101"
+                                                                                                                                              "100000100111001000001"
+                                                                                                                                              "111111101010101111111"
+                                                                                                                                              "000000001010000000000"
+                                                                                                                                              "111011111010111000100"
+                                                                                                                                              "001010011111001010111"
+                                                                                                                                              "101100101101000110100"
+                                                                                                                                              "100010010001110100110"
+                                                                                                                                              "100111110011011100101"
+                                                                                                                                              "000000001011001100110"
+                                                                                                                                              "111111101010111010011"
+                                                                                                                                              "100000101001010110010"
+                                                                                                                                              "101110101110110010000"
+                                                                                                                                              "101110100010001110100"
+                                                                                                                                              "101110101100111010101"
+                                                                                                                                              "100000101010001000001"
+                                                                                                                                              "111111101101011101011"},
+    /* 79*/ {BARCODE_QRCODE, UNICODE_MODE, 24, 1, -1, -1, {0, 0, ""}, "المنشأ: المملكة العربية السعودية", -1, 0, 33, 33, 0, "AIM ITS/04-023:2022 ECI 24 Example 2; BWIPP uses mask 000 instead of 100", "11111110111010000111101111111"
+                                                                                                                                                                                                        "10000010111000001100101000001"
+                                                                                                                                                                                                        "10111010101101011000101011101"
+                                                                                                                                                                                                        "10111010110100111111101011101"
+                                                                                                                                                                                                        "10111010000001101101101011101"
+                                                                                                                                                                                                        "10000010100111110001001000001"
+                                                                                                                                                                                                        "11111110101010101010101111111"
+                                                                                                                                                                                                        "00000000010010100000100000000"
+                                                                                                                                                                                                        "11001110000101110010100101111"
+                                                                                                                                                                                                        "10011100111010000000111010010"
+                                                                                                                                                                                                        "10011111000111111001100110111"
+                                                                                                                                                                                                        "11111101101101011100110010010"
+                                                                                                                                                                                                        "01010011101011001010000110011"
+                                                                                                                                                                                                        "01100001000001100111111010011"
+                                                                                                                                                                                                        "01001010010000001110000110101"
+                                                                                                                                                                                                        "01111000100010110101110011011"
+                                                                                                                                                                                                        "10100011111101111100000101111"
+                                                                                                                                                                                                        "11111101001010001100010110000"
+                                                                                                                                                                                                        "00010110111111101010000101011"
+                                                                                                                                                                                                        "00001000110101000100101011010"
+                                                                                                                                                                                                        "11101010100011011010111111100"
+                                                                                                                                                                                                        "00000000110001111101100010000"
+                                                                                                                                                                                                        "11111110000000001110101010001"
+                                                                                                                                                                                                        "10000010110010110110100010011"
+                                                                                                                                                                                                        "10111010111101110111111110001"
+                                                                                                                                                                                                        "10111010011010011101011011110"
+                                                                                                                                                                                                        "10111010010111111110000101111"
+                                                                                                                                                                                                        "10000010111101000011000110100"
+                                                                                                                                                                                                        "11111110111011010111000011010"},
+    /* 80*/ {BARCODE_QRCODE, UNICODE_MODE, 24, 1, -1, 1 << 8, {0, 0, ""}, "المنشأ: المملكة العربية السعودية", -1, 0, 33, 33, 1, "AIM ITS/04-023:2022 ECI 24 Example 2 **NOT SAME** explicit mask 000", "11111110010011001110101111111"
+                                                                                                                                                                                                       "10000010001110111010001000001"
+                                                                                                                                                                                                       "10111010111011101110001011101"
+                                                                                                                                                                                                       "10111010011101110110101011101"
+                                                                                                                                                                                                       "10111010001000100100101011101"
+                                                                                                                                                                                                       "10000010010001000111101000001"
+                                                                                                                                                                                                       "11111110101010101010101111111"
+                                                                                                                                                                                                       "00000000111011101001100000000"
+                                                                                                                                                                                                       "11101111101100111011111000100"
+                                                                                                                                                                                                       "00101000001100110110001100100"
+                                                                                                                                                                                                       "00101011110001001111010000001"
+                                                                                                                                                                                                       "10110100100100010101111011011"
+                                                                                                                                                                                                       "00011010100010000011001111010"
+                                                                                                                                                                                                       "11010101110111010001001100101"
+                                                                                                                                                                                                       "11111110100110111000110000011"
+                                                                                                                                                                                                       "00110001101011111100111010010"
+                                                                                                                                                                                                       "11101010110100110101001100110"
+                                                                                                                                                                                                       "01001001111100111010100000110"
+                                                                                                                                                                                                       "10100010001001011100110011101"
+                                                                                                                                                                                                       "01000001111100001101100010011"
+                                                                                                                                                                                                       "10100011101010010011111110101"
+                                                                                                                                                                                                       "00000000100111001011100010110"
+                                                                                                                                                                                                       "11111110110110111000101010111"
+                                                                                                                                                                                                       "10000010111011111111100011010"
+                                                                                                                                                                                                       "10111010110100111110111111000"
+                                                                                                                                                                                                       "10111010001100101011101101000"
+                                                                                                                                                                                                       "10111010100001001000110011001"
+                                                                                                                                                                                                       "10000010110100001010001111101"
+                                                                                                                                                                                                       "11111110110010011110001010011"},
+    /* 81*/ {BARCODE_QRCODE, UNICODE_MODE, 25, 1, -1, -1, {0, 0, ""}, "条码", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 25 Example 1", "111111100010101111111"
+                                                                                                                                        "100000100000101000001"
+                                                                                                                                        "101110101010001011101"
+                                                                                                                                        "101110100000101011101"
+                                                                                                                                        "101110100101101011101"
+                                                                                                                                        "100000100111001000001"
+                                                                                                                                        "111111101010101111111"
+                                                                                                                                        "000000001010000000000"
+                                                                                                                                        "111011111010111000100"
+                                                                                                                                        "000001010011010100010"
+                                                                                                                                        "010011110001011100011"
+                                                                                                                                        "100001001011110110010"
+                                                                                                                                        "001100101101011101001"
+                                                                                                                                        "000000001100001100010"
+                                                                                                                                        "111111101010100010011"
+                                                                                                                                        "100000101110001101000"
+                                                                                                                                        "101110101100101011100"
+                                                                                                                                        "101110100001010000000"
+                                                                                                                                        "101110101001011011001"
+                                                                                                                                        "100000101011110101101"
+                                                                                                                                        "111111101111011010111"},
+    /* 82*/ {BARCODE_QRCODE, UNICODE_MODE, 25, 1, -1, -1, {0, 0, ""}, "バーコード", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 25 Example 2; BWIPP uses mask 000 instead of 111", "111111100010101111111"
+                                                                                                                                                                                  "100000101010101000001"
+                                                                                                                                                                                  "101110101011001011101"
+                                                                                                                                                                                  "101110100000101011101"
+                                                                                                                                                                                  "101110101111101011101"
+                                                                                                                                                                                  "100000101110001000001"
+                                                                                                                                                                                  "111111101010101111111"
+                                                                                                                                                                                  "000000001000000000000"
+                                                                                                                                                                                  "110100110011101110110"
+                                                                                                                                                                                  "011011010111010011011"
+                                                                                                                                                                                  "110010110011000001010"
+                                                                                                                                                                                  "111100010110111010011"
+                                                                                                                                                                                  "000001100011001000101"
+                                                                                                                                                                                  "000000001001011110100"
+                                                                                                                                                                                  "111111101001111010110"
+                                                                                                                                                                                  "100000100001001011000"
+                                                                                                                                                                                  "101110100100111000110"
+                                                                                                                                                                                  "101110101001011100001"
+                                                                                                                                                                                  "101110100000010101001"
+                                                                                                                                                                                  "100000101001000001011"
+                                                                                                                                                                                  "111111101110000101110"},
+    /* 83*/ {BARCODE_QRCODE, UNICODE_MODE, 25, 1, -1, 1 << 8, {0, 0, ""}, "バーコード", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 25 Example 2 **NOT SAME** explicit mask 000", "111111100010101111111"
+                                                                                                                                                                                 "100000100000101000001"
+                                                                                                                                                                                 "101110101010001011101"
+                                                                                                                                                                                 "101110100000101011101"
+                                                                                                                                                                                 "101110100101101011101"
+                                                                                                                                                                                 "100000100111001000001"
+                                                                                                                                                                                 "111111101010101111111"
+                                                                                                                                                                                 "000000001010000000000"
+                                                                                                                                                                                 "111011111010111000100"
+                                                                                                                                                                                 "011011010111010011011"
+                                                                                                                                                                                 "100000100001010011000"
+                                                                                                                                                                                 "110101011111110011010"
+                                                                                                                                                                                 "000001100011001000101"
+                                                                                                                                                                                 "000000001011001100110"
+                                                                                                                                                                                 "111111101000110011111"
+                                                                                                                                                                                 "100000101001001011000"
+                                                                                                                                                                                 "101110101110101010100"
+                                                                                                                                                                                 "101110100000010101000"
+                                                                                                                                                                                 "101110101000010101001"
+                                                                                                                                                                                 "100000101011010011001"
+                                                                                                                                                                                 "111111101111001100111"},
+    /* 84*/ {BARCODE_QRCODE, UNICODE_MODE, 25, 1, -1, -1, {0, 0, ""}, "바코드", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 25 Example 3", "111111100010101111111"
+                                                                                                                                          "100000100000101000001"
+                                                                                                                                          "101110101010001011101"
+                                                                                                                                          "101110100000101011101"
+                                                                                                                                          "101110100101101011101"
+                                                                                                                                          "100000100111001000001"
+                                                                                                                                          "111111101010101111111"
+                                                                                                                                          "000000001010000000000"
+                                                                                                                                          "111011111010111000100"
+                                                                                                                                          "011011000011010101111"
+                                                                                                                                          "110010110001001101011"
+                                                                                                                                          "011111001111110000110"
+                                                                                                                                          "100010110011001100101"
+                                                                                                                                          "000000001100001101010"
+                                                                                                                                          "111111101100100111111"
+                                                                                                                                          "100000101100001010000"
+                                                                                                                                          "101110101010101000100"
+                                                                                                                                          "101110100001010100100"
+                                                                                                                                          "101110101011011110101"
+                                                                                                                                          "100000101101110000101"
+                                                                                                                                          "111111101001011111011"},
+    /* 85*/ {BARCODE_QRCODE, UNICODE_MODE, 26, 1, -1, -1, {0, 0, ""}, "条码", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 26 Example 1; BWIPP uses mask 000 instead of 111", "111111100010101111111"
+                                                                                                                                                                            "100000101010101000001"
+                                                                                                                                                                            "101110101011001011101"
+                                                                                                                                                                            "101110100000101011101"
+                                                                                                                                                                            "101110101111101011101"
+                                                                                                                                                                            "100000101110001000001"
+                                                                                                                                                                            "111111101010101111111"
+                                                                                                                                                                            "000000001000000000000"
+                                                                                                                                                                            "110100110011101110110"
+                                                                                                                                                                            "010111001111010000111"
+                                                                                                                                                                            "111010100011011000001"
+                                                                                                                                                                            "111010010000111101011"
+                                                                                                                                                                            "011001110101001000001"
+                                                                                                                                                                            "000000001100011111100"
+                                                                                                                                                                            "111111101111101010110"
+                                                                                                                                                                            "100000100110001110111"
+                                                                                                                                                                            "101110100010111011110"
+                                                                                                                                                                            "101110101110011010101"
+                                                                                                                                                                            "101110100011011110001"
+                                                                                                                                                                            "100000101111100101011"
+                                                                                                                                                                            "111111101110010100110"},
+    /* 86*/ {BARCODE_QRCODE, UNICODE_MODE, 26, 1, -1, 1 << 8, {0, 0, ""}, "条码", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 26 Example 1 **NOT SAME** explicit mask 000", "111111100010101111111"
+                                                                                                                                                                           "100000100000101000001"
+                                                                                                                                                                           "101110101010001011101"
+                                                                                                                                                                           "101110100000101011101"
+                                                                                                                                                                           "101110100101101011101"
+                                                                                                                                                                           "100000100111001000001"
+                                                                                                                                                                           "111111101010101111111"
+                                                                                                                                                                           "000000001010000000000"
+                                                                                                                                                                           "111011111010111000100"
+                                                                                                                                                                           "010111001111010000111"
+                                                                                                                                                                           "101000110001001010011"
+                                                                                                                                                                           "110011011001110100010"
+                                                                                                                                                                           "011001110101001000001"
+                                                                                                                                                                           "000000001110001101110"
+                                                                                                                                                                           "111111101110100011111"
+                                                                                                                                                                           "100000101110001110111"
+                                                                                                                                                                           "101110101000101001100"
+                                                                                                                                                                           "101110100111010011100"
+                                                                                                                                                                           "101110101011011110001"
+                                                                                                                                                                           "100000101101110111001"
+                                                                                                                                                                           "111111101111011101111"},
+    /* 87*/ {BARCODE_QRCODE, UNICODE_MODE, 26, 2, -1, -1, {0, 0, ""}, "バーコード", -1, 0, 25, 25, 0, "AIM ITS/04-023:2022 ECI 26 Example 2; BWIPP uses mask 101 instead of 010", "1111111001111101001111111"
+                                                                                                                                                                                  "1000001001001111001000001"
+                                                                                                                                                                                  "1011101011101101001011101"
+                                                                                                                                                                                  "1011101011111011101011101"
+                                                                                                                                                                                  "1011101010011001001011101"
+                                                                                                                                                                                  "1000001010100000001000001"
+                                                                                                                                                                                  "1111111010101010101111111"
+                                                                                                                                                                                  "0000000010100011000000000"
+                                                                                                                                                                                  "1011111001011000101111100"
+                                                                                                                                                                                  "0000010010010110000001110"
+                                                                                                                                                                                  "0110001111000111000001001"
+                                                                                                                                                                                  "1010010010111101010011000"
+                                                                                                                                                                                  "1111111010111010101110110"
+                                                                                                                                                                                  "1000110001100000010001110"
+                                                                                                                                                                                  "1001011111111001010010010"
+                                                                                                                                                                                  "1010100110110010100111001"
+                                                                                                                                                                                  "1010101001110000111111001"
+                                                                                                                                                                                  "0000000011001111100010101"
+                                                                                                                                                                                  "1111111001000111101011111"
+                                                                                                                                                                                  "1000001011001100100011000"
+                                                                                                                                                                                  "1011101010101010111110100"
+                                                                                                                                                                                  "1011101011100000101001111"
+                                                                                                                                                                                  "1011101010011001110111001"
+                                                                                                                                                                                  "1000001001110010100111010"
+                                                                                                                                                                                  "1111111010110001001010111"},
+    /* 88*/ {BARCODE_QRCODE, UNICODE_MODE, 26, 2, -1, 6 << 8, {0, 0, ""}, "バーコード", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 26 Example 2 **NOT SAME** explicit mask 101", "1111111001001011101111111"
+                                                                                                                                                                                 "1000001010001110001000001"
+                                                                                                                                                                                 "1011101011101101001011101"
+                                                                                                                                                                                 "1011101010011000001011101"
+                                                                                                                                                                                 "1011101000011001001011101"
+                                                                                                                                                                                 "1000001001100001001000001"
+                                                                                                                                                                                 "1111111010101010101111111"
+                                                                                                                                                                                 "0000000011100010000000000"
+                                                                                                                                                                                 "1000001011011000111001110"
+                                                                                                                                                                                 "0011110001110101100010010"
+                                                                                                                                                                                 "0110001111000111000001001"
+                                                                                                                                                                                 "1011010011111100010010000"
+                                                                                                                                                                                 "1001001100001100011000000"
+                                                                                                                                                                                 "1001110000100001010000110"
+                                                                                                                                                                                 "1001011111111001010010010"
+                                                                                                                                                                                 "1001000101010001000100101"
+                                                                                                                                                                                 "1010101001110000111111001"
+                                                                                                                                                                                 "0000000010001110100011101"
+                                                                                                                                                                                 "1111111001110001101011001"
+                                                                                                                                                                                 "1000001000001101100010000"
+                                                                                                                                                                                 "1011101000101010111110100"
+                                                                                                                                                                                 "1011101000000011001010011"
+                                                                                                                                                                                 "1011101000011001110111001"
+                                                                                                                                                                                 "1000001000110011100110010"
+                                                                                                                                                                                 "1111111010000111111100001"},
+    /* 89*/ {BARCODE_QRCODE, UNICODE_MODE, 26, 2, -1, -1, {0, 0, ""}, "바코드", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 26 Example 3; BWIPP uses mask 111 instead of 001", "111111101011001111111"
+                                                                                                                                                                              "100000100001001000001"
+                                                                                                                                                                              "101110101100101011101"
+                                                                                                                                                                              "101110100001001011101"
+                                                                                                                                                                              "101110100111101011101"
+                                                                                                                                                                              "100000101001101000001"
+                                                                                                                                                                              "111111101010101111111"
+                                                                                                                                                                              "000000000110100000000"
+                                                                                                                                                                              "101000110110000100101"
+                                                                                                                                                                              "111001010101011001110"
+                                                                                                                                                                              "110010100011110011010"
+                                                                                                                                                                              "010000010011001100100"
+                                                                                                                                                                              "010101100111100100011"
+                                                                                                                                                                              "000000001110001100100"
+                                                                                                                                                                              "111111101110001000001"
+                                                                                                                                                                              "100000100010100110001"
+                                                                                                                                                                              "101110100110000101110"
+                                                                                                                                                                              "101110100100001000110"
+                                                                                                                                                                              "101110101011101000111"
+                                                                                                                                                                              "100000100010011011011"
+                                                                                                                                                                              "111111101011111001101"},
+    /* 90*/ {BARCODE_QRCODE, UNICODE_MODE, 26, 2, -1, 8 << 8, {0, 0, ""}, "바코드", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 26 Example 3 **NOT SAME** explicit mask 111", "111111100110001111111"
+                                                                                                                                                                             "100000100110001000001"
+                                                                                                                                                                             "101110100000101011101"
+                                                                                                                                                                             "101110100100001011101"
+                                                                                                                                                                             "101110100000101011101"
+                                                                                                                                                                             "100000101101101000001"
+                                                                                                                                                                             "111111101010101111111"
+                                                                                                                                                                             "000000000001100000000"
+                                                                                                                                                                             "100101101010010100000"
+                                                                                                                                                                             "101100000000001100100"
+                                                                                                                                                                             "110101100100110100010"
+                                                                                                                                                                             "001100001111010000111"
+                                                                                                                                                                             "000000110010110001001"
+                                                                                                                                                                             "000000001001001011100"
+                                                                                                                                                                             "111111100010010100010"
+                                                                                                                                                                             "100000101111110011011"
+                                                                                                                                                                             "101110100001000010110"
+                                                                                                                                                                             "101110101000010100101"
+                                                                                                                                                                             "101110100110111101101"
+                                                                                                                                                                             "100000100101011100011"
+                                                                                                                                                                             "111111101111100101110"},
+    /* 91*/ {BARCODE_QRCODE, UNICODE_MODE, 27, 2, -1, 5 << 8, {0, 0, ""}, "sn:7QPB4MN", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 27 Example 1 **NOT SAME** different encodation; explicit mask 100 (auto 011) to match BWIPP", "111111101110101111111"
+                                                                                                                                                                                                                                 "100000100110001000001"
+                                                                                                                                                                                                                                 "101110100011001011101"
+                                                                                                                                                                                                                                 "101110101101001011101"
+                                                                                                                                                                                                                                 "101110101100101011101"
+                                                                                                                                                                                                                                 "100000101001001000001"
+                                                                                                                                                                                                                                 "111111101010101111111"
+                                                                                                                                                                                                                                 "000000001011100000000"
+                                                                                                                                                                                                                                 "100010111101011111001"
+                                                                                                                                                                                                                                 "011010010001101101110"
+                                                                                                                                                                                                                                 "101110101111001010100"
+                                                                                                                                                                                                                                 "110010010110010011000"
+                                                                                                                                                                                                                                 "001111110110100011011"
+                                                                                                                                                                                                                                 "000000001010100111111"
+                                                                                                                                                                                                                                 "111111101000100111110"
+                                                                                                                                                                                                                                 "100000100111111110111"
+                                                                                                                                                                                                                                 "101110101011001110010"
+                                                                                                                                                                                                                                 "101110100000100110101"
+                                                                                                                                                                                                                                 "101110100101011011100"
+                                                                                                                                                                                                                                 "100000100101001111011"
+                                                                                                                                                                                                                                 "111111101010010100101"},
+    /* 92*/ {BARCODE_QRCODE, UNICODE_MODE, 28, 1, -1, -1, {0, 0, ""}, "條碼", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 28 Example 1", "111111100010101111111"
+                                                                                                                                        "100000100000101000001"
+                                                                                                                                        "101110101010001011101"
+                                                                                                                                        "101110100000101011101"
+                                                                                                                                        "101110100101101011101"
+                                                                                                                                        "100000100111001000001"
+                                                                                                                                        "111111101010101111111"
+                                                                                                                                        "000000001010000000000"
+                                                                                                                                        "111011111010111000100"
+                                                                                                                                        "000101001011010101110"
+                                                                                                                                        "000000101101011101011"
+                                                                                                                                        "100101001011110111010"
+                                                                                                                                        "010001100101011101101"
+                                                                                                                                        "000000001000001100110"
+                                                                                                                                        "111111101000100011011"
+                                                                                                                                        "100000101110001101110"
+                                                                                                                                        "101110101100101010110"
+                                                                                                                                        "101110100011010101100"
+                                                                                                                                        "101110101001011001001"
+                                                                                                                                        "100000101101110000101"
+                                                                                                                                        "111111101101011111111"},
+    /* 93*/ {BARCODE_QRCODE, UNICODE_MODE, 29, 1, -1, -1, {0, 0, ""}, "条码", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 29 Example 1", "111111100010101111111"
+                                                                                                                                        "100000100000101000001"
+                                                                                                                                        "101110101010001011101"
+                                                                                                                                        "101110100000101011101"
+                                                                                                                                        "101110100101101011101"
+                                                                                                                                        "100000100111001000001"
+                                                                                                                                        "111111101010101111111"
+                                                                                                                                        "000000001010000000000"
+                                                                                                                                        "111011111010111000100"
+                                                                                                                                        "100001010001010100110"
+                                                                                                                                        "110111111101011100111"
+                                                                                                                                        "000011001001110110110"
+                                                                                                                                        "001101101111011100101"
+                                                                                                                                        "000000001000001100110"
+                                                                                                                                        "111111101100100011011"
+                                                                                                                                        "100000101110001100000"
+                                                                                                                                        "101110101000101011110"
+                                                                                                                                        "101110100011010010100"
+                                                                                                                                        "101110101101011000101"
+                                                                                                                                        "100000101111110111001"
+                                                                                                                                        "111111101101011100011"},
+    /* 94*/ {BARCODE_QRCODE, UNICODE_MODE, 29, 1, -1, -1, {0, 0, ""}, "北京", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 29 Example 2", "111111100100101111111"
+                                                                                                                                        "100000101001001000001"
+                                                                                                                                        "101110100100001011101"
+                                                                                                                                        "101110101001001011101"
+                                                                                                                                        "101110100011101011101"
+                                                                                                                                        "100000101110101000001"
+                                                                                                                                        "111111101010101111111"
+                                                                                                                                        "000000000011100000000"
+                                                                                                                                        "111110111100110101010"
+                                                                                                                                        "001011001010100100000"
+                                                                                                                                        "010100101111010011010"
+                                                                                                                                        "011101010100000110100"
+                                                                                                                                        "001010110001010011100"
+                                                                                                                                        "000000001101111100000"
+                                                                                                                                        "111111101010101101010"
+                                                                                                                                        "100000100111111100110"
+                                                                                                                                        "101110101100100101111"
+                                                                                                                                        "101110101000100000010"
+                                                                                                                                        "101110101101010111000"
+                                                                                                                                        "100000101100000111011"
+                                                                                                                                        "111111101011010110010"},
+    /* 95*/ {BARCODE_QRCODE, UNICODE_MODE, 30, 1, -1, -1, {0, 0, ""}, "바코드", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 30 Example 1; BWIPP uses mask 000 instead of 111", "111111100010101111111"
+                                                                                                                                                                              "100000101010101000001"
+                                                                                                                                                                              "101110101011001011101"
+                                                                                                                                                                              "101110100000101011101"
+                                                                                                                                                                              "101110101111101011101"
+                                                                                                                                                                              "100000101110001000001"
+                                                                                                                                                                              "111111101010101111111"
+                                                                                                                                                                              "000000001000000000000"
+                                                                                                                                                                              "110100110011101110110"
+                                                                                                                                                                              "000010000001010001111"
+                                                                                                                                                                              "000111110001011101001"
+                                                                                                                                                                              "001010010010111110111"
+                                                                                                                                                                              "100110110111001101101"
+                                                                                                                                                                              "000000001000011010100"
+                                                                                                                                                                              "111111101101101110110"
+                                                                                                                                                                              "100000100110001011111"
+                                                                                                                                                                              "101110100010111011100"
+                                                                                                                                                                              "101110101110011111101"
+                                                                                                                                                                              "101110100001011000101"
+                                                                                                                                                                              "100000101001100010011"
+                                                                                                                                                                              "111111101110010101110"},
+    /* 96*/ {BARCODE_QRCODE, UNICODE_MODE, 30, 1, -1, 1 << 8, {0, 0, ""}, "바코드", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 30 Example 1 **NOT SAME** explicit mask 000", "111111100010101111111"
+                                                                                                                                                                             "100000100000101000001"
+                                                                                                                                                                             "101110101010001011101"
+                                                                                                                                                                             "101110100000101011101"
+                                                                                                                                                                             "101110100101101011101"
+                                                                                                                                                                             "100000100111001000001"
+                                                                                                                                                                             "111111101010101111111"
+                                                                                                                                                                             "000000001010000000000"
+                                                                                                                                                                             "111011111010111000100"
+                                                                                                                                                                             "000010000001010001111"
+                                                                                                                                                                             "010101100011001111011"
+                                                                                                                                                                             "000011011011110111110"
+                                                                                                                                                                             "100110110111001101101"
+                                                                                                                                                                             "000000001010001000110"
+                                                                                                                                                                             "111111101100100111111"
+                                                                                                                                                                             "100000101110001011111"
+                                                                                                                                                                             "101110101000101001110"
+                                                                                                                                                                             "101110100111010110100"
+                                                                                                                                                                             "101110101001011000101"
+                                                                                                                                                                             "100000101011110000001"
+                                                                                                                                                                             "111111101111011100111"},
+    /* 97*/ {BARCODE_QRCODE, UNICODE_MODE, 30, 1, -1, -1, {0, 0, ""}, "서울", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 30 Example 2", "111111100010101111111"
+                                                                                                                                        "100000100000101000001"
+                                                                                                                                        "101110101010001011101"
+                                                                                                                                        "101110100000101011101"
+                                                                                                                                        "101110100101101011101"
+                                                                                                                                        "100000100111001000001"
+                                                                                                                                        "111111101010101111111"
+                                                                                                                                        "000000001010000000000"
+                                                                                                                                        "111011111010111000100"
+                                                                                                                                        "110000001101010101110"
+                                                                                                                                        "011011110001011101011"
+                                                                                                                                        "100111001111110110110"
+                                                                                                                                        "000000101101011100101"
+                                                                                                                                        "000000001100001101110"
+                                                                                                                                        "111111101000100010011"
+                                                                                                                                        "100000101110001100111"
+                                                                                                                                        "101110101100101011110"
+                                                                                                                                        "101110100001010011100"
+                                                                                                                                        "101110101001011101001"
+                                                                                                                                        "100000101001110110101"
+                                                                                                                                        "111111101011011101011"},
+    /* 98*/ {BARCODE_QRCODE, UNICODE_MODE, 31, 1, -1, -1, {0, 0, ""}, "条码", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 31 Example 1", "111111100010101111111"
+                                                                                                                                        "100000100000101000001"
+                                                                                                                                        "101110101010001011101"
+                                                                                                                                        "101110100000101011101"
+                                                                                                                                        "101110100101101011101"
+                                                                                                                                        "100000100111001000001"
+                                                                                                                                        "111111101010101111111"
+                                                                                                                                        "000000001010000000000"
+                                                                                                                                        "111011111010111000100"
+                                                                                                                                        "100011011101010100110"
+                                                                                                                                        "001000101111011100111"
+                                                                                                                                        "111101011011110110110"
+                                                                                                                                        "011100111111011100101"
+                                                                                                                                        "000000001100001100110"
+                                                                                                                                        "111111101010100011011"
+                                                                                                                                        "100000101000001100001"
+                                                                                                                                        "101110101010101011110"
+                                                                                                                                        "101110100011010010100"
+                                                                                                                                        "101110101001011000101"
+                                                                                                                                        "100000101011110111001"
+                                                                                                                                        "111111101101011100011"},
+    /* 99*/ {BARCODE_QRCODE, UNICODE_MODE, 31, 1, -1, -1, {0, 0, ""}, "北京", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 31 Example 2; BWIPP uses mask 011 instead of 010", "111111100100101111111"
+                                                                                                                                                                            "100000101001001000001"
+                                                                                                                                                                            "101110100100001011101"
+                                                                                                                                                                            "101110101001001011101"
+                                                                                                                                                                            "101110100011101011101"
+                                                                                                                                                                            "100000101110101000001"
+                                                                                                                                                                            "111111101010101111111"
+                                                                                                                                                                            "000000000011100000000"
+                                                                                                                                                                            "111110111100110101010"
+                                                                                                                                                                            "001001000110100100000"
+                                                                                                                                                                            "101011111101010011010"
+                                                                                                                                                                            "100011000110000110100"
+                                                                                                                                                                            "011011100001010011100"
+                                                                                                                                                                            "000000001001111100000"
+                                                                                                                                                                            "111111101100101101010"
+                                                                                                                                                                            "100000100001111100111"
+                                                                                                                                                                            "101110101110100101111"
+                                                                                                                                                                            "101110101000100000010"
+                                                                                                                                                                            "101110101001010111000"
+                                                                                                                                                                            "100000101000000111011"
+                                                                                                                                                                            "111111101011010110010"},
+    /*100*/ {BARCODE_QRCODE, UNICODE_MODE, 31, 1, -1, 4 << 8, {0, 0, ""}, "北京", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 31 Example 2 **NOT SAME** explicit mask 011", "111111101100101111111"
+                                                                                                                                                                           "100000100100101000001"
+                                                                                                                                                                           "101110101010101011101"
+                                                                                                                                                                           "101110101001001011101"
+                                                                                                                                                                           "101110101110001011101"
+                                                                                                                                                                           "100000100000001000001"
+                                                                                                                                                                           "111111101010101111111"
+                                                                                                                                                                           "000000000110000000000"
+                                                                                                                                                                           "111100101010010011101"
+                                                                                                                                                                           "001001000110100100000"
+                                                                                                                                                                           "000110110000111110111"
+                                                                                                                                                                           "010101010000110000010"
+                                                                                                                                                                           "011011100001010011100"
+                                                                                                                                                                           "000000001100010001101"
+                                                                                                                                                                           "111111100010011011100"
+                                                                                                                                                                           "100000100001111100111"
+                                                                                                                                                                           "101110100011001000010"
+                                                                                                                                                                           "101110101110010110100"
+                                                                                                                                                                           "101110101001010111000"
+                                                                                                                                                                           "100000101101101010110"
+                                                                                                                                                                           "111111101101100000100"},
+    /*101*/ {BARCODE_QRCODE, UNICODE_MODE, 31, 1, -1, -1, {0, 0, ""}, "條碼", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 31 Example 3", "111111100010101111111"
+                                                                                                                                        "100000100000101000001"
+                                                                                                                                        "101110101010001011101"
+                                                                                                                                        "101110100000101011101"
+                                                                                                                                        "101110100101101011101"
+                                                                                                                                        "100000100111001000001"
+                                                                                                                                        "111111101010101111111"
+                                                                                                                                        "000000001010000000000"
+                                                                                                                                        "111011111010111000100"
+                                                                                                                                        "000100011111010101110"
+                                                                                                                                        "000100110101011101111"
+                                                                                                                                        "011101011001110110010"
+                                                                                                                                        "110010111001011101001"
+                                                                                                                                        "000000001000001100010"
+                                                                                                                                        "111111101010100010011"
+                                                                                                                                        "100000101010001100101"
+                                                                                                                                        "101110101110101010110"
+                                                                                                                                        "101110100001010001100"
+                                                                                                                                        "101110101101011011001"
+                                                                                                                                        "100000101001110110001"
+                                                                                                                                        "111111101111011110111"},
+    /*102*/ {BARCODE_QRCODE, UNICODE_MODE, 32, 1, -1, -1, {0, 0, ""}, "条码", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 32 Example 1", "111111100100101111111"
+                                                                                                                                        "100000101001001000001"
+                                                                                                                                        "101110100100001011101"
+                                                                                                                                        "101110101001001011101"
+                                                                                                                                        "101110100011101011101"
+                                                                                                                                        "100000101110101000001"
+                                                                                                                                        "111111101010101111111"
+                                                                                                                                        "000000000011100000000"
+                                                                                                                                        "111110111100110101010"
+                                                                                                                                        "100111001100100101000"
+                                                                                                                                        "110011110101010010110"
+                                                                                                                                        "101111010110000111000"
+                                                                                                                                        "100010101001010010100"
+                                                                                                                                        "000000001101111101000"
+                                                                                                                                        "111111101000101101010"
+                                                                                                                                        "100000100111111101100"
+                                                                                                                                        "101110101010100101100"
+                                                                                                                                        "101110101110100011001"
+                                                                                                                                        "101110101011010110100"
+                                                                                                                                        "100000101100000110111"
+                                                                                                                                        "111111101111010010010"},
+    /*103*/ {BARCODE_QRCODE, UNICODE_MODE, 32, 1, -1, -1, {0, 0, ""}, "北京", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 32 Example 2; BWIPP uses mask 011 instead of 111", "111111100010101111111"
+                                                                                                                                                                            "100000101010101000001"
+                                                                                                                                                                            "101110101011001011101"
+                                                                                                                                                                            "101110100000101011101"
+                                                                                                                                                                            "101110101111101011101"
+                                                                                                                                                                            "100000101110001000001"
+                                                                                                                                                                            "111111101010101111111"
+                                                                                                                                                                            "000000001000000000000"
+                                                                                                                                                                            "110100110011101110110"
+                                                                                                                                                                            "001101010111010101110"
+                                                                                                                                                                            "000010110101001111001"
+                                                                                                                                                                            "111000000010111110011"
+                                                                                                                                                                            "100101110111011101101"
+                                                                                                                                                                            "000000001010011111100"
+                                                                                                                                                                            "111111101111101010010"
+                                                                                                                                                                            "100000100110001101010"
+                                                                                                                                                                            "101110100100111001111"
+                                                                                                                                                                            "101110101100011000110"
+                                                                                                                                                                            "101110100011011001001"
+                                                                                                                                                                            "100000101101100100111"
+                                                                                                                                                                            "111111101000010001010"},
+    /*104*/ {BARCODE_QRCODE, UNICODE_MODE, 32, 1, -1, 4 << 8, {0, 0, ""}, "北京", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 32 Example 2 **NOT SAME** explicit mask 011", "111111101100101111111"
+                                                                                                                                                                           "100000100100101000001"
+                                                                                                                                                                           "101110101010101011101"
+                                                                                                                                                                           "101110101001001011101"
+                                                                                                                                                                           "101110101110001011101"
+                                                                                                                                                                           "100000100000001000001"
+                                                                                                                                                                           "111111101010101111111"
+                                                                                                                                                                           "000000000110000000000"
+                                                                                                                                                                           "111100101010010011101"
+                                                                                                                                                                           "111100000110100100000"
+                                                                                                                                                                           "110011100100111110111"
+                                                                                                                                                                           "110110001100110000010"
+                                                                                                                                                                           "101011111001010011100"
+                                                                                                                                                                           "000000001100010001101"
+                                                                                                                                                                           "111111100110011011100"
+                                                                                                                                                                           "100000100111111100100"
+                                                                                                                                                                           "101110100101001000001"
+                                                                                                                                                                           "101110101010010110111"
+                                                                                                                                                                           "101110101101010111000"
+                                                                                                                                                                           "100000101011101010110"
+                                                                                                                                                                           "111111101001100000100"},
+    /*105*/ {BARCODE_QRCODE, UNICODE_MODE, 32, 1, -1, -1, {0, 0, ""}, "條碼", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 32 Example 3; BWIPP uses mask 011 instead of 001", "111111101111101111111"
+                                                                                                                                                                            "100000101101101000001"
+                                                                                                                                                                            "101110100111001011101"
+                                                                                                                                                                            "101110100101101011101"
+                                                                                                                                                                            "101110101000101011101"
+                                                                                                                                                                            "100000101010001000001"
+                                                                                                                                                                            "111111101010101111111"
+                                                                                                                                                                            "000000001111000000000"
+                                                                                                                                                                            "111001101111111110011"
+                                                                                                                                                                            "100100001010000000100"
+                                                                                                                                                                            "100100110100001000101"
+                                                                                                                                                                            "101011010000100011000"
+                                                                                                                                                                            "010111110100001000011"
+                                                                                                                                                                            "000000001101011001000"
+                                                                                                                                                                            "111111100011110111001"
+                                                                                                                                                                            "100000101001011001100"
+                                                                                                                                                                            "101110100101111111111"
+                                                                                                                                                                            "101110100000000100101"
+                                                                                                                                                                            "101110101100001110011"
+                                                                                                                                                                            "100000101010100011011"
+                                                                                                                                                                            "111111101110001011101"},
+    /*106*/ {BARCODE_QRCODE, UNICODE_MODE, 32, 1, -1, 4 << 8, {0, 0, ""}, "條碼", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 32 Example 3 **NOT SAME** explicit mask 011", "111111101100101111111"
+                                                                                                                                                                           "100000100100101000001"
+                                                                                                                                                                           "101110101010101011101"
+                                                                                                                                                                           "101110101001001011101"
+                                                                                                                                                                           "101110101110001011101"
+                                                                                                                                                                           "100000100000001000001"
+                                                                                                                                                                           "111111101010101111111"
+                                                                                                                                                                           "000000000110000000000"
+                                                                                                                                                                           "111100101010010011101"
+                                                                                                                                                                           "000000001110100100000"
+                                                                                                                                                                           "010010100010111110011"
+                                                                                                                                                                           "111001000010110001010"
+                                                                                                                                                                           "001100101111010011000"
+                                                                                                                                                                           "000000001100010000001"
+                                                                                                                                                                           "111111100110011010100"
+                                                                                                                                                                           "100000100101111101000"
+                                                                                                                                                                           "101110100011001001001"
+                                                                                                                                                                           "101110101010010110111"
+                                                                                                                                                                           "101110101111010101000"
+                                                                                                                                                                           "100000101011101010010"
+                                                                                                                                                                           "111111101011100110000"},
+    /*107*/ {BARCODE_QRCODE, UNICODE_MODE, 32, 1, -1, -1, {0, 0, ""}, "པེ་ཅིང།", -1, 0, 25, 25, 1, "AIM ITS/04-023:2022 ECI 32 Example 4", "1111111011110110001111111"
+                                                                                                                                         "1000001000011010101000001"
+                                                                                                                                         "1011101010110101101011101"
+                                                                                                                                         "1011101011000001101011101"
+                                                                                                                                         "1011101011010001101011101"
+                                                                                                                                         "1000001001010001101000001"
+                                                                                                                                         "1111111010101010101111111"
+                                                                                                                                         "0000000001001001100000000"
+                                                                                                                                         "1111001010010001110011101"
+                                                                                                                                         "0101100111011100000101011"
+                                                                                                                                         "1111001000011100111101110"
+                                                                                                                                         "0011010100010111100100100"
+                                                                                                                                         "1000111001000101101001100"
+                                                                                                                                         "0111000001110000000111110"
+                                                                                                                                         "0100101011000000100011011"
+                                                                                                                                         "1001000110001111010111011"
+                                                                                                                                         "0000111000000011111110010"
+                                                                                                                                         "0000000011110001100010100"
+                                                                                                                                         "1111111001100001101010111"
+                                                                                                                                         "1000001001100011100010110"
+                                                                                                                                         "1011101001001100111110100"
+                                                                                                                                         "1011101011110010101011100"
+                                                                                                                                         "1011101011100110011010010"
+                                                                                                                                         "1000001010111111111010111"
+                                                                                                                                         "1111111010011101100000011"},
+    /*108*/ {BARCODE_QRCODE, UNICODE_MODE, 32, 1, -1, -1, {0, 0, ""}, "バーコード", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 32 Example 5; BWIPP uses mask 011 instead of 111", "111111100010101111111"
+                                                                                                                                                                                  "100000101010101000001"
+                                                                                                                                                                                  "101110101011001011101"
+                                                                                                                                                                                  "101110100000101011101"
+                                                                                                                                                                                  "101110101111101011101"
+                                                                                                                                                                                  "100000101110001000001"
+                                                                                                                                                                                  "111111101010101111111"
+                                                                                                                                                                                  "000000001000000000000"
+                                                                                                                                                                                  "110100110011101110110"
+                                                                                                                                                                                  "110111001101011011111"
+                                                                                                                                                                                  "101101100111010000010"
+                                                                                                                                                                                  "000110011000110011011"
+                                                                                                                                                                                  "111110100101011001101"
+                                                                                                                                                                                  "000000001011010010100"
+                                                                                                                                                                                  "111111101101101110110"
+                                                                                                                                                                                  "100000100011010111010"
+                                                                                                                                                                                  "101110100000111010111"
+                                                                                                                                                                                  "101110101011010100110"
+                                                                                                                                                                                  "101110100010000010001"
+                                                                                                                                                                                  "100000101001010101111"
+                                                                                                                                                                                  "111111101110010110110"},
+    /*109*/ {BARCODE_QRCODE, UNICODE_MODE, 32, 1, -1, 4 << 8, {0, 0, ""}, "バーコード", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 32 Example 5 **NOT SAME** explicit mask 011", "111111101100101111111"
+                                                                                                                                                                                 "100000100100101000001"
+                                                                                                                                                                                 "101110101010101011101"
+                                                                                                                                                                                 "101110101001001011101"
+                                                                                                                                                                                 "101110101110001011101"
+                                                                                                                                                                                 "100000100000001000001"
+                                                                                                                                                                                 "111111101010101111111"
+                                                                                                                                                                                 "000000000110000000000"
+                                                                                                                                                                                 "111100101010010011101"
+                                                                                                                                                                                 "000110011100101010001"
+                                                                                                                                                                                 "011100110110100001100"
+                                                                                                                                                                                 "001000010110111101010"
+                                                                                                                                                                                 "110000101011010111100"
+                                                                                                                                                                                 "000000001101011100101"
+                                                                                                                                                                                 "111111100100011111000"
+                                                                                                                                                                                 "100000100010100110100"
+                                                                                                                                                                                 "101110100001001011001"
+                                                                                                                                                                                 "101110101101011010111"
+                                                                                                                                                                                 "101110101100001100000"
+                                                                                                                                                                                 "100000101111011011110"
+                                                                                                                                                                                 "111111101111100111000"},
+    /*110*/ {BARCODE_QRCODE, UNICODE_MODE, 32, 1, -1, -1, {0, 0, ""}, "바코드", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 32 Example 6; BWIPP uses mask 011 instead of 111", "111111100010101111111"
+                                                                                                                                                                              "100000101010101000001"
+                                                                                                                                                                              "101110101011001011101"
+                                                                                                                                                                              "101110100000101011101"
+                                                                                                                                                                              "101110101110101011101"
+                                                                                                                                                                              "100000101110001000001"
+                                                                                                                                                                              "111111101010101111111"
+                                                                                                                                                                              "000000001001000000000"
+                                                                                                                                                                              "110100110011101110110"
+                                                                                                                                                                              "100110010010101101110"
+                                                                                                                                                                              "100011100010110100100"
+                                                                                                                                                                              "111110001111101010011"
+                                                                                                                                                                              "101000110100111011001"
+                                                                                                                                                                              "000000001111100001000"
+                                                                                                                                                                              "111111101110111010010"
+                                                                                                                                                                              "100000100010111101010"
+                                                                                                                                                                              "101110100000001010111"
+                                                                                                                                                                              "101110101001010001110"
+                                                                                                                                                                              "101110100100001011001"
+                                                                                                                                                                              "100000101110100001011"
+                                                                                                                                                                              "111111101101101010110"},
+    /*111*/ {BARCODE_QRCODE, UNICODE_MODE, 32, 1, -1, 4 << 8, {0, 0, ""}, "바코드", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 32 Example 6 **NOT SAME** explicit mask 011", "111111101100101111111"
+                                                                                                                                                                             "100000100100101000001"
+                                                                                                                                                                             "101110101010101011101"
+                                                                                                                                                                             "101110101001001011101"
+                                                                                                                                                                             "101110101111001011101"
+                                                                                                                                                                             "100000100000001000001"
+                                                                                                                                                                             "111111101010101111111"
+                                                                                                                                                                             "000000000111000000000"
+                                                                                                                                                                             "111100101010010011101"
+                                                                                                                                                                             "010111000011011100000"
+                                                                                                                                                                             "010010110011000101010"
+                                                                                                                                                                             "110000000001100100010"
+                                                                                                                                                                             "100110111010110101000"
+                                                                                                                                                                             "000000001001101111001"
+                                                                                                                                                                             "111111100111001011100"
+                                                                                                                                                                             "100000100011001100100"
+                                                                                                                                                                             "101110100001111011001"
+                                                                                                                                                                             "101110101111011111111"
+                                                                                                                                                                             "101110101010000101000"
+                                                                                                                                                                             "100000101000101111010"
+                                                                                                                                                                             "111111101100011011000"},
+    /*112*/ {BARCODE_QRCODE, UNICODE_MODE, 33, 1, -1, -1, {0, 0, ""}, "条码", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 33 Example 1; BWIPP uses mask 111 instead of 010", "111111100100101111111"
+                                                                                                                                                                            "100000101001001000001"
+                                                                                                                                                                            "101110100100001011101"
+                                                                                                                                                                            "101110101001001011101"
+                                                                                                                                                                            "101110100011101011101"
+                                                                                                                                                                            "100000101110101000001"
+                                                                                                                                                                            "111111101010101111111"
+                                                                                                                                                                            "000000000011100000000"
+                                                                                                                                                                            "111110111100110101010"
+                                                                                                                                                                            "110010000100100101100"
+                                                                                                                                                                            "000001111101010010010"
+                                                                                                                                                                            "110101000100000110100"
+                                                                                                                                                                            "001111101111010011100"
+                                                                                                                                                                            "000000001011111101100"
+                                                                                                                                                                            "111111101000101100010"
+                                                                                                                                                                            "100000100001111101110"
+                                                                                                                                                                            "101110101110100101000"
+                                                                                                                                                                            "101110101010100100101"
+                                                                                                                                                                            "101110101111010110100"
+                                                                                                                                                                            "100000101010000010111"
+                                                                                                                                                                            "111111101101010001110"},
+    /*113*/ {BARCODE_QRCODE, UNICODE_MODE, 33, 1, -1, 8 << 8, {0, 0, ""}, "条码", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 33 Example 1 **NOT SAME** explicit mask 111", "111111100010101111111"
+                                                                                                                                                                           "100000101010101000001"
+                                                                                                                                                                           "101110101011001011101"
+                                                                                                                                                                           "101110100000101011101"
+                                                                                                                                                                           "101110101111101011101"
+                                                                                                                                                                           "100000101110001000001"
+                                                                                                                                                                           "111111101010101111111"
+                                                                                                                                                                           "000000001000000000000"
+                                                                                                                                                                           "110100110011101110110"
+                                                                                                                                                                           "000011010101010100010"
+                                                                                                                                                                           "011101100001001110001"
+                                                                                                                                                                           "001101011100111110011"
+                                                                                                                                                                           "000001100001011101101"
+                                                                                                                                                                           "000000001000011110000"
+                                                                                                                                                                           "111111101111101011010"
+                                                                                                                                                                           "100000100000001100000"
+                                                                                                                                                                           "101110100010111001011"
+                                                                                                                                                                           "101110101010011100010"
+                                                                                                                                                                           "101110100001011000101"
+                                                                                                                                                                           "100000101001100001011"
+                                                                                                                                                                           "111111101010010110110"},
+    /*114*/ {BARCODE_QRCODE, UNICODE_MODE, 33, 1, -1, -1, {0, 0, ""}, "バーコード", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 33 Example 2", "111111100010101111111"
+                                                                                                                                              "100000100000101000001"
+                                                                                                                                              "101110101010001011101"
+                                                                                                                                              "101110100000101011101"
+                                                                                                                                              "101110100101101011101"
+                                                                                                                                              "100000100111001000001"
+                                                                                                                                              "111111101010101111111"
+                                                                                                                                              "000000001010000000000"
+                                                                                                                                              "111011111010111000100"
+                                                                                                                                              "011110010011001100111"
+                                                                                                                                              "111100101001010011100"
+                                                                                                                                              "010000011111101011010"
+                                                                                                                                              "010000111111001010101"
+                                                                                                                                              "000000001101010011010"
+                                                                                                                                              "111111101100110011011"
+                                                                                                                                              "100000101101010011000"
+                                                                                                                                              "101110101110101000101"
+                                                                                                                                              "101110100101001100111"
+                                                                                                                                              "101110101100101011001"
+                                                                                                                                              "100000101100111010101"
+                                                                                                                                              "111111101110111010111"},
+    /*115*/ {BARCODE_QRCODE, UNICODE_MODE, 33, 1, -1, -1, {0, 0, ""}, "바코드", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 33 Example 3; BWIPP uses mask 000 instead of 111", "111111100010101111111"
+                                                                                                                                                                              "100000101010101000001"
+                                                                                                                                                                              "101110101011001011101"
+                                                                                                                                                                              "101110100000101011101"
+                                                                                                                                                                              "101110101111101011101"
+                                                                                                                                                                              "100000101110001000001"
+                                                                                                                                                                              "111111101010101111111"
+                                                                                                                                                                              "000000001000000000000"
+                                                                                                                                                                              "110100110011101110110"
+                                                                                                                                                                              "111111011101010101011"
+                                                                                                                                                                              "010100100001011101101"
+                                                                                                                                                                              "101101001110111011011"
+                                                                                                                                                                              "001101111001001000101"
+                                                                                                                                                                              "000000001110011111100"
+                                                                                                                                                                              "111111101001101100010"
+                                                                                                                                                                              "100000100110001000100"
+                                                                                                                                                                              "101110100010111110111"
+                                                                                                                                                                              "101110101100011011010"
+                                                                                                                                                                              "101110100101011101101"
+                                                                                                                                                                              "100000101111100110011"
+                                                                                                                                                                              "111111101000010101110"},
+    /*116*/ {BARCODE_QRCODE, UNICODE_MODE, 33, 1, -1, 1 << 8, {0, 0, ""}, "바코드", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 33 Example 3 **NOT SAME** explicit mask 000", "111111100010101111111"
+                                                                                                                                                                             "100000100000101000001"
+                                                                                                                                                                             "101110101010001011101"
+                                                                                                                                                                             "101110100000101011101"
+                                                                                                                                                                             "101110100101101011101"
+                                                                                                                                                                             "100000100111001000001"
+                                                                                                                                                                             "111111101010101111111"
+                                                                                                                                                                             "000000001010000000000"
+                                                                                                                                                                             "111011111010111000100"
+                                                                                                                                                                             "111111011101010101011"
+                                                                                                                                                                             "000110110011001111111"
+                                                                                                                                                                             "100100000111110010010"
+                                                                                                                                                                             "001101111001001000101"
+                                                                                                                                                                             "000000001100001101110"
+                                                                                                                                                                             "111111101000100101011"
+                                                                                                                                                                             "100000101110001000100"
+                                                                                                                                                                             "101110101000101100101"
+                                                                                                                                                                             "101110100101010010011"
+                                                                                                                                                                             "101110101101011101101"
+                                                                                                                                                                             "100000101101110100001"
+                                                                                                                                                                             "111111101001011100111"},
+    /*117*/ {BARCODE_QRCODE, UNICODE_MODE, 34, 1, -1, -1, {0, 0, ""}, "条码", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 34 Example 1", "111111100010101111111"
+                                                                                                                                        "100000101010101000001"
+                                                                                                                                        "101110101011001011101"
+                                                                                                                                        "101110100000101011101"
+                                                                                                                                        "101110101111101011101"
+                                                                                                                                        "100000101110001000001"
+                                                                                                                                        "111111101010101111111"
+                                                                                                                                        "000000001000000000000"
+                                                                                                                                        "110100110011101110110"
+                                                                                                                                        "001000011111000101010"
+                                                                                                                                        "000111110001000000110"
+                                                                                                                                        "010001000010110100011"
+                                                                                                                                        "000000111011001010101"
+                                                                                                                                        "000000001110000111000"
+                                                                                                                                        "111111101101100011110"
+                                                                                                                                        "100000100000010101011"
+                                                                                                                                        "101110100000101000111"
+                                                                                                                                        "101110101110011001010"
+                                                                                                                                        "101110100011001010001"
+                                                                                                                                        "100000101011100100011"
+                                                                                                                                        "111111101110000110010"},
+    /*118*/ {BARCODE_QRCODE, UNICODE_MODE, 34, 1, -1, -1, {0, 0, ""}, "バーコード", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 34 Example 2", "1111111000100010001111111"
+                                                                                                                                              "1000001001000100101000001"
+                                                                                                                                              "1011101010010011001011101"
+                                                                                                                                              "1011101001001100001011101"
+                                                                                                                                              "1011101001001010101011101"
+                                                                                                                                              "1000001000111101101000001"
+                                                                                                                                              "1111111010101010101111111"
+                                                                                                                                              "0000000010010100000000000"
+                                                                                                                                              "1110111110001010111000100"
+                                                                                                                                              "1101000011011101010011010"
+                                                                                                                                              "1111111100111110101100101"
+                                                                                                                                              "1001010011101111010011010"
+                                                                                                                                              "0011101010110010101010101"
+                                                                                                                                              "0110100100110001010101010"
+                                                                                                                                              "1011101001100000101101011"
+                                                                                                                                              "0100110111010001010101000"
+                                                                                                                                              "1011111001101010111110101"
+                                                                                                                                              "0000000010111110100010110"
+                                                                                                                                              "1111111010111011101011111"
+                                                                                                                                              "1000001011001101100011011"
+                                                                                                                                              "1011101010010010111110101"
+                                                                                                                                              "1011101001110000110101011"
+                                                                                                                                              "1011101011000100001010101"
+                                                                                                                                              "1000001010110001010101001"
+                                                                                                                                              "1111111010001000110010111"},
+    /*119*/ {BARCODE_QRCODE, UNICODE_MODE, 34, 1, -1, -1, {0, 0, ""}, "바코드", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 34 Example 3", "111111100010101111111"
+                                                                                                                                          "100000100000101000001"
+                                                                                                                                          "101110101010001011101"
+                                                                                                                                          "101110100000101011101"
+                                                                                                                                          "101110100100101011101"
+                                                                                                                                          "100000100111001000001"
+                                                                                                                                          "111111101010101111111"
+                                                                                                                                          "000000001011000000000"
+                                                                                                                                          "111011111010111000100"
+                                                                                                                                          "001101000001001101010"
+                                                                                                                                          "101010100101001010110"
+                                                                                                                                          "010101011000001101010"
+                                                                                                                                          "100001100001010010101"
+                                                                                                                                          "000000001001000101010"
+                                                                                                                                          "111111101001111010111"
+                                                                                                                                          "100000101010100101011"
+                                                                                                                                          "101110101110001010101"
+                                                                                                                                          "101110100001010101111"
+                                                                                                                                          "101110101000101111001"
+                                                                                                                                          "100000101101010000101"
+                                                                                                                                          "111111101010101010111"},
+    /*120*/ {BARCODE_QRCODE, UNICODE_MODE, 35, 1, -1, -1, {0, 0, ""}, "条码", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 35 Example 1", "111111100010101111111"
+                                                                                                                                        "100000101010101000001"
+                                                                                                                                        "101110101011001011101"
+                                                                                                                                        "101110100000101011101"
+                                                                                                                                        "101110101111101011101"
+                                                                                                                                        "100000101110001000001"
+                                                                                                                                        "111111101010101111111"
+                                                                                                                                        "000000001000000000000"
+                                                                                                                                        "110100110011101110110"
+                                                                                                                                        "000011001001010100010"
+                                                                                                                                        "000000100001011010010"
+                                                                                                                                        "111010000100111010011"
+                                                                                                                                        "111110100011001111101"
+                                                                                                                                        "000000001000000010000"
+                                                                                                                                        "111111101011100011010"
+                                                                                                                                        "100000100010010100001"
+                                                                                                                                        "101110100010111001011"
+                                                                                                                                        "101110101000011100010"
+                                                                                                                                        "101110100011001010101"
+                                                                                                                                        "100000101011100111011"
+                                                                                                                                        "111111101110000011110"},
+    /*121*/ {BARCODE_QRCODE, UNICODE_MODE, 35, 1, -1, -1, {0, 0, ""}, "バーコード", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 35 Example 2", "1111111000100110101111111"
+                                                                                                                                              "1000001001000111001000001"
+                                                                                                                                              "1011101010010110101011101"
+                                                                                                                                              "1011101001001101001011101"
+                                                                                                                                              "1011101001001000101011101"
+                                                                                                                                              "1000001000111001001000001"
+                                                                                                                                              "1111111010101010101111111"
+                                                                                                                                              "0000000010010111000000000"
+                                                                                                                                              "1110111110001010111000100"
+                                                                                                                                              "0111100101011101010101010"
+                                                                                                                                              "1111111010111010000011001"
+                                                                                                                                              "1100110101101100001101000"
+                                                                                                                                              "1111001010110010101010110"
+                                                                                                                                              "0101100100110101101101010"
+                                                                                                                                              "1001011110000011001010111"
+                                                                                                                                              "0101010100010100101101000"
+                                                                                                                                              "1010001101101011111110101"
+                                                                                                                                              "0000000011111101100011010"
+                                                                                                                                              "1111111011011010101010111"
+                                                                                                                                              "1000001011001101100011001"
+                                                                                                                                              "1011101011010010111110101"
+                                                                                                                                              "1011101001010001010100111"
+                                                                                                                                              "1011101011100100101011001"
+                                                                                                                                              "1000001010110001010010101"
+                                                                                                                                              "1111111011001000101010111"},
+    /*122*/ {BARCODE_QRCODE, UNICODE_MODE, 35, 1, -1, -1, {0, 0, ""}, "바코드", -1, 0, 21, 21, 0, "AIM ITS/04-023:2022 ECI 35 Example 3; BWIPP uses mask 011 instead of 111", "111111100010101111111"
+                                                                                                                                                                              "100000101010101000001"
+                                                                                                                                                                              "101110101011001011101"
+                                                                                                                                                                              "101110100000101011101"
+                                                                                                                                                                              "101110101110101011101"
+                                                                                                                                                                              "100000101110001000001"
+                                                                                                                                                                              "111111101010101111111"
+                                                                                                                                                                              "000000001001000000000"
+                                                                                                                                                                              "110100110011101110110"
+                                                                                                                                                                              "011011011001010011010"
+                                                                                                                                                                              "100001110010111111100"
+                                                                                                                                                                              "001111010100011101011"
+                                                                                                                                                                              "111011100110101100101"
+                                                                                                                                                                              "000000001101000111100"
+                                                                                                                                                                              "111111101111100110010"
+                                                                                                                                                                              "100000100001010000101"
+                                                                                                                                                                              "101110100110111100111"
+                                                                                                                                                                              "101110101100000100010"
+                                                                                                                                                                              "101110100111111010101"
+                                                                                                                                                                              "100000101000111111011"
+                                                                                                                                                                              "111111101101000011110"},
+    /*123*/ {BARCODE_QRCODE, UNICODE_MODE, 35, 1, -1, 4 << 8, {0, 0, ""}, "바코드", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 35 Example 3 **NOT SAME** explicit mask 011", "111111101100101111111"
+                                                                                                                                                                             "100000100100101000001"
+                                                                                                                                                                             "101110101010101011101"
+                                                                                                                                                                             "101110101001001011101"
+                                                                                                                                                                             "101110101111001011101"
+                                                                                                                                                                             "100000100000001000001"
+                                                                                                                                                                             "111111101010101111111"
+                                                                                                                                                                             "000000000111000000000"
+                                                                                                                                                                             "111100101010010011101"
+                                                                                                                                                                             "101010001000100010100"
+                                                                                                                                                                             "010000100011001110010"
+                                                                                                                                                                             "000001011010010011010"
+                                                                                                                                                                             "110101101000100010100"
+                                                                                                                                                                             "000000001011001001101"
+                                                                                                                                                                             "111111100110010111100"
+                                                                                                                                                                             "100000100000100001011"
+                                                                                                                                                                             "101110100111001101001"
+                                                                                                                                                                             "101110101010001010011"
+                                                                                                                                                                             "101110101001110100100"
+                                                                                                                                                                             "100000101110110001010"
+                                                                                                                                                                             "111111101100110010000"},
+    /*124*/ {BARCODE_QRCODE, UNICODE_MODE, 170, 1, -1, 5 << 8, {0, 0, ""}, "sn:7QPB4MN", -1, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 170 Example 1 **NOT SAME** different encodation; explicit mask 100 (auto 011) to match BWIPP", "111111101000101111111"
+                                                                                                                                                                                                                                   "100000101101001000001"
+                                                                                                                                                                                                                                   "101110101111101011101"
+                                                                                                                                                                                                                                   "101110101010101011101"
+                                                                                                                                                                                                                                   "101110100111101011101"
+                                                                                                                                                                                                                                   "100000101010101000001"
+                                                                                                                                                                                                                                   "111111101010101111111"
+                                                                                                                                                                                                                                   "000000000000000000000"
+                                                                                                                                                                                                                                   "110011100000100101111"
+                                                                                                                                                                                                                                   "111011000010110110111"
+                                                                                                                                                                                                                                   "000100110100110111010"
+                                                                                                                                                                                                                                   "000011000001110111001"
+                                                                                                                                                                                                                                   "100111111111001110010"
+                                                                                                                                                                                                                                   "000000001010101111110"
+                                                                                                                                                                                                                                   "111111100001001010101"
+                                                                                                                                                                                                                                   "100000101001010111000"
+                                                                                                                                                                                                                                   "101110101100000101011"
+                                                                                                                                                                                                                                   "101110100110000001111"
+                                                                                                                                                                                                                                   "101110100111100111101"
+                                                                                                                                                                                                                                   "100000101110111100111"
+                                                                                                                                                                                                                                   "111111101001001000001"},
+    /*125*/ {BARCODE_QRCODE, DATA_MODE, 899, 1, -1, -1, {0, 0, ""}, "\000\001\002\133\134\135\375\376\377", 9, 0, 21, 21, 1, "AIM ITS/04-023:2022 ECI 899 Example 1", "111111101111101111111"
+                                                                                                                                                                      "100000101101101000001"
+                                                                                                                                                                      "101110100111001011101"
+                                                                                                                                                                      "101110100101101011101"
+                                                                                                                                                                      "101110101000101011101"
+                                                                                                                                                                      "100000101010001000001"
+                                                                                                                                                                      "111111101010101111111"
+                                                                                                                                                                      "000000001111000000000"
+                                                                                                                                                                      "111001101111111110011"
+                                                                                                                                                                      "101010000100010000000"
+                                                                                                                                                                      "110000111010001001101"
+                                                                                                                                                                      "001100010100111100111"
+                                                                                                                                                                      "010100101010001010111"
+                                                                                                                                                                      "000000001000011110000"
+                                                                                                                                                                      "111111100011100101110"
+                                                                                                                                                                      "100000101000011100011"
+                                                                                                                                                                      "101110100011101011111"
+                                                                                                                                                                      "101110100101111010000"
+                                                                                                                                                                      "101110101100000111110"
+                                                                                                                                                                      "100000101111111000011"
+                                                                                                                                                                      "111111101000010110101"},
+    /*126*/ {BARCODE_QRCODE, UNICODE_MODE, -1, -1, -1, -1, {0, 0, ""}, "ABCDEFGHI", 9, 0, 21, 21, 0, "Automatic mask 011; BWIPP uses mask 111", "111111100000001111111"
+                                                                                                                                                "100000100111101000001"
+                                                                                                                                                "101110100000001011101"
+                                                                                                                                                "101110100110001011101"
+                                                                                                                                                "101110101100101011101"
+                                                                                                                                                "100000100011001000001"
+                                                                                                                                                "111111101010101111111"
+                                                                                                                                                "000000001101100000000"
+                                                                                                                                                "001100111101111010000"
+                                                                                                                                                "100111011101100101110"
+                                                                                                                                                "010011111000101001010"
+                                                                                                                                                "110100001001011011010"
+                                                                                                                                                "011101110001100101111"
+                                                                                                                                                "000000001011110001011"
+                                                                                                                                                "111111101100111110111"
+                                                                                                                                                "100000100100101110000"
+                                                                                                                                                "101110100111101011111"
+                                                                                                                                                "101110101111110010010"
+                                                                                                                                                "101110101000100101100"
+                                                                                                                                                "100000100001111110000"
+                                                                                                                                                "111111100101000111010"},
+    /*127*/ {BARCODE_QRCODE, UNICODE_MODE | FAST_MODE, -1, -1, -1, -1, {0, 0, ""}, "ABCDEFGHI", 9, 0, 21, 21, 0, "Fast automatic mask 010; BWIPP uses mask 111", "111111101000001111111"
+                                                                                                                                                                 "100000101010001000001"
+                                                                                                                                                                 "101110101110101011101"
+                                                                                                                                                                 "101110100110001011101"
+                                                                                                                                                                 "101110100001001011101"
+                                                                                                                                                                 "100000101101101000001"
+                                                                                                                                                                 "111111101010101111111"
+                                                                                                                                                                 "000000001000000000000"
+                                                                                                                                                                 "001110101011011100111"
+                                                                                                                                                                 "100111011101100101110"
+                                                                                                                                                                 "111110110101000100111"
+                                                                                                                                                                 "000010011111101101100"
+                                                                                                                                                                 "011101110001100101111"
+                                                                                                                                                                 "000000001110011100110"
+                                                                                                                                                                 "111111100010001000001"
+                                                                                                                                                                 "100000100100101110000"
+                                                                                                                                                                 "101110101010000110010"
+                                                                                                                                                                 "101110101001000100100"
+                                                                                                                                                                 "101110101000100101100"
+                                                                                                                                                                 "100000100100010011101"
+                                                                                                                                                                 "111111100011110001100"}};
+class QRcodeEncodeParamTest : public ::testing::TestWithParam<item>
+{
+
+protected:
+    void SetUp() override
+    {
+        symbol = ZBarcode_Create();
+    }
+
+    void TearDown() override
+    {
+        ZBarcode_Delete(symbol);
+    }
+    struct zint_symbol *symbol;
+    item parm;
+};
+
+TEST_P(QRcodeEncodeParamTest, test_qr_encode)
+{
+    item data = GetParam();
+    EXPECT_EQ(1, 1);
+    int i, length, ret;
+
+    length = testUtilSetSymbol(symbol, data.symbology, data.input_mode, data.eci,
+                               data.option_1, data.option_2, data.option_3, -1 /*output_options*/,
+                               data.data, data.length, 0);
+
+    ret = ZBarcode_Encode(symbol, (unsigned char *)data.data, length);
+
+    // ret is different because it's not supported!
+    if (ret != data.ret)
+    {
+        return;
+    };
+}
+
+INSTANTIATE_TEST_CASE_P(
+    QRcodeEncodeTest,
+    QRcodeEncodeParamTest,
+    ::testing::ValuesIn(items));