Merging upstream version 1.45.3+dfsg.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

282 files changed, 5340 insertions, 0 deletions

diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/.gitattributes b/src/fluent-bit/lib/jansson-e23f558/test/suites/.gitattributes
new file mode 100644
index 000000000..68d88612c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/.gitattributes
@@ -0,0 +1,2 @@
+api/ text=auto
+* text eol=lf
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/Makefile.am b/src/fluent-bit/lib/jansson-e23f558/test/suites/Makefile.am
new file mode 100644
index 000000000..a53eb07f1
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/Makefile.am
@@ -0,0 +1,2 @@
+SUBDIRS = api
+EXTRA_DIST = invalid invalid-unicode valid
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/Makefile.am b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/Makefile.am
new file mode 100644
index 000000000..2bc638b82
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/Makefile.am
@@ -0,0 +1,42 @@
+EXTRA_DIST = run check-exports
+
+check_PROGRAMS = \
+	test_array \
+	test_chaos \
+	test_copy \
+	test_dump \
+	test_dump_callback \
+	test_equal \
+	test_fixed_size \
+	test_load \
+	test_load_callback \
+	test_loadb \
+	test_memory_funcs \
+	test_number \
+	test_object \
+	test_pack \
+	test_simple \
+	test_sprintf \
+	test_unpack \
+	test_version
+
+test_array_SOURCES = test_array.c util.h
+test_chaos_SOURCES = test_chaos.c util.h
+test_copy_SOURCES = test_copy.c util.h
+test_dump_SOURCES = test_dump.c util.h
+test_dump_callback_SOURCES = test_dump_callback.c util.h
+test_fixed_size_SOURCES = test_fixed_size.c util.h
+test_load_SOURCES = test_load.c util.h
+test_loadb_SOURCES = test_loadb.c util.h
+test_memory_funcs_SOURCES = test_memory_funcs.c util.h
+test_number_SOURCES = test_number.c util.h
+test_object_SOURCES = test_object.c util.h
+test_pack_SOURCES = test_pack.c util.h
+test_simple_SOURCES = test_simple.c util.h
+test_sprintf_SOURCES = test_sprintf.c util.h
+test_unpack_SOURCES = test_unpack.c util.h
+test_version_SOURCES = test_version.c util.h
+
+AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src
+LDFLAGS = -static  # for speed and Valgrind
+LDADD = $(top_builddir)/src/libjansson.la
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/check-exports b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/check-exports
new file mode 100755
index 000000000..5c82064c1
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/check-exports
@@ -0,0 +1,23 @@
+#!/bin/sh
+#
+# This test checks that libjansson.so exports the correct symbols.
+#
+
+SOFILE="../src/.libs/libjansson.so"
+
+# The list of symbols, which the shared object should export, is read
+# from the def file, which is used in Windows builds
+grep 'json_\|jansson_' $top_srcdir/src/jansson.def \
+    | sed -e 's/ //g' \
+    | sort \
+    >$test_log/exports
+
+nm -D $SOFILE >/dev/null >$test_log/symbols 2>/dev/null \
+    || exit 77  # Skip if "nm -D" doesn't seem to work
+
+grep ' [DT] ' $test_log/symbols | cut -d' ' -f3 | grep -v '^_' | sed 's/@@libjansson.*//' | sort >$test_log/output
+
+if ! cmp -s $test_log/exports $test_log/output; then
+    diff -u $test_log/exports $test_log/output >&2
+    exit 1
+fi
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/run b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/run
new file mode 100755
index 000000000..0c017bca6
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/run
@@ -0,0 +1,36 @@
+#!/bin/sh
+#
+# Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+#
+# Jansson is free software; you can redistribute it and/or modify
+# it under the terms of the MIT license. See LICENSE for details.
+
+is_test() {
+    case "$test_name" in
+        *.c|check-exports)
+            return 0
+            ;;
+        *)
+            return 1
+            ;;
+    esac
+}
+
+run_test() {
+    if [ "$test_name" = "check-exports" ]; then
+        test_log=$test_log $test_path >$test_log/stdout 2>$test_log/stderr
+    else
+        $test_runner $suite_builddir/${test_name%.c} \
+            >$test_log/stdout \
+            2>$test_log/stderr \
+            || return 1
+        valgrind_check $test_log/stderr || return 1
+    fi
+}
+
+show_error() {
+    valgrind_show_error && return
+    cat $test_log/stderr
+}
+
+. $top_srcdir/test/scripts/run-tests.sh
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_array.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_array.c
new file mode 100644
index 000000000..e5d9d1a19
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_array.c
@@ -0,0 +1,484 @@
+/*
+ * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "util.h"
+#include <jansson.h>
+
+static void test_misc(void) {
+    json_t *array, *five, *seven, *value;
+    size_t i;
+
+    array = json_array();
+    five = json_integer(5);
+    seven = json_integer(7);
+
+    if (!array)
+        fail("unable to create array");
+    if (!five || !seven)
+        fail("unable to create integer");
+
+    if (json_array_size(array) != 0)
+        fail("empty array has nonzero size");
+
+    if (!json_array_append(array, NULL))
+        fail("able to append NULL");
+
+    if (json_array_append(array, five))
+        fail("unable to append");
+
+    if (json_array_size(array) != 1)
+        fail("wrong array size");
+
+    value = json_array_get(array, 0);
+    if (!value)
+        fail("unable to get item");
+    if (value != five)
+        fail("got wrong value");
+
+    if (json_array_append(array, seven))
+        fail("unable to append value");
+
+    if (json_array_size(array) != 2)
+        fail("wrong array size");
+
+    value = json_array_get(array, 1);
+    if (!value)
+        fail("unable to get item");
+    if (value != seven)
+        fail("got wrong value");
+
+    if (json_array_set(array, 0, seven))
+        fail("unable to set value");
+
+    if (!json_array_set(array, 0, NULL))
+        fail("able to set NULL");
+
+    if (json_array_size(array) != 2)
+        fail("wrong array size");
+
+    value = json_array_get(array, 0);
+    if (!value)
+        fail("unable to get item");
+    if (value != seven)
+        fail("got wrong value");
+
+    if (json_array_get(array, 2) != NULL)
+        fail("able to get value out of bounds");
+
+    if (!json_array_set(array, 2, seven))
+        fail("able to set value out of bounds");
+
+    for (i = 2; i < 30; i++) {
+        if (json_array_append(array, seven))
+            fail("unable to append value");
+
+        if (json_array_size(array) != i + 1)
+            fail("wrong array size");
+    }
+
+    for (i = 0; i < 30; i++) {
+        value = json_array_get(array, i);
+        if (!value)
+            fail("unable to get item");
+        if (value != seven)
+            fail("got wrong value");
+    }
+
+    if (json_array_set_new(array, 15, json_integer(123)))
+        fail("unable to set new value");
+
+    value = json_array_get(array, 15);
+    if (!json_is_integer(value) || json_integer_value(value) != 123)
+        fail("json_array_set_new works incorrectly");
+
+    if (!json_array_set_new(array, 15, NULL))
+        fail("able to set_new NULL value");
+
+    if (json_array_append_new(array, json_integer(321)))
+        fail("unable to append new value");
+
+    value = json_array_get(array, json_array_size(array) - 1);
+    if (!json_is_integer(value) || json_integer_value(value) != 321)
+        fail("json_array_append_new works incorrectly");
+
+    if (!json_array_append_new(array, NULL))
+        fail("able to append_new NULL value");
+
+    json_decref(five);
+    json_decref(seven);
+    json_decref(array);
+}
+
+static void test_insert(void) {
+    json_t *array, *five, *seven, *eleven, *value;
+    int i;
+
+    array = json_array();
+    five = json_integer(5);
+    seven = json_integer(7);
+    eleven = json_integer(11);
+
+    if (!array)
+        fail("unable to create array");
+    if (!five || !seven || !eleven)
+        fail("unable to create integer");
+
+    if (!json_array_insert(array, 1, five))
+        fail("able to insert value out of bounds");
+
+    if (json_array_insert(array, 0, five))
+        fail("unable to insert value in an empty array");
+
+    if (json_array_get(array, 0) != five)
+        fail("json_array_insert works incorrectly");
+
+    if (json_array_size(array) != 1)
+        fail("array size is invalid after insertion");
+
+    if (json_array_insert(array, 1, seven))
+        fail("unable to insert value at the end of an array");
+
+    if (json_array_get(array, 0) != five)
+        fail("json_array_insert works incorrectly");
+
+    if (json_array_get(array, 1) != seven)
+        fail("json_array_insert works incorrectly");
+
+    if (json_array_size(array) != 2)
+        fail("array size is invalid after insertion");
+
+    if (json_array_insert(array, 1, eleven))
+        fail("unable to insert value in the middle of an array");
+
+    if (json_array_get(array, 0) != five)
+        fail("json_array_insert works incorrectly");
+
+    if (json_array_get(array, 1) != eleven)
+        fail("json_array_insert works incorrectly");
+
+    if (json_array_get(array, 2) != seven)
+        fail("json_array_insert works incorrectly");
+
+    if (json_array_size(array) != 3)
+        fail("array size is invalid after insertion");
+
+    if (json_array_insert_new(array, 2, json_integer(123)))
+        fail("unable to insert value in the middle of an array");
+
+    value = json_array_get(array, 2);
+    if (!json_is_integer(value) || json_integer_value(value) != 123)
+        fail("json_array_insert_new works incorrectly");
+
+    if (json_array_size(array) != 4)
+        fail("array size is invalid after insertion");
+
+    for (i = 0; i < 20; i++) {
+        if (json_array_insert(array, 0, seven))
+            fail("unable to insert value at the beginning of an array");
+    }
+
+    for (i = 0; i < 20; i++) {
+        if (json_array_get(array, i) != seven)
+            fail("json_aray_insert works incorrectly");
+    }
+
+    if (json_array_size(array) != 24)
+        fail("array size is invalid after loop insertion");
+
+    json_decref(five);
+    json_decref(seven);
+    json_decref(eleven);
+    json_decref(array);
+}
+
+static void test_remove(void) {
+    json_t *array, *five, *seven;
+    int i;
+
+    array = json_array();
+    five = json_integer(5);
+    seven = json_integer(7);
+
+    if (!array)
+        fail("unable to create array");
+    if (!five)
+        fail("unable to create integer");
+    if (!seven)
+        fail("unable to create integer");
+
+    if (!json_array_remove(array, 0))
+        fail("able to remove an unexisting index");
+
+    if (json_array_append(array, five))
+        fail("unable to append");
+
+    if (!json_array_remove(array, 1))
+        fail("able to remove an unexisting index");
+
+    if (json_array_remove(array, 0))
+        fail("unable to remove");
+
+    if (json_array_size(array) != 0)
+        fail("array size is invalid after removing");
+
+    if (json_array_append(array, five) || json_array_append(array, seven) ||
+        json_array_append(array, five) || json_array_append(array, seven))
+        fail("unable to append");
+
+    if (json_array_remove(array, 2))
+        fail("unable to remove");
+
+    if (json_array_size(array) != 3)
+        fail("array size is invalid after removing");
+
+    if (json_array_get(array, 0) != five || json_array_get(array, 1) != seven ||
+        json_array_get(array, 2) != seven)
+        fail("remove works incorrectly");
+
+    json_decref(array);
+
+    array = json_array();
+    for (i = 0; i < 4; i++) {
+        json_array_append(array, five);
+        json_array_append(array, seven);
+    }
+    if (json_array_size(array) != 8)
+        fail("unable to append 8 items to array");
+
+    /* Remove an element from a "full" array. */
+    json_array_remove(array, 5);
+
+    json_decref(five);
+    json_decref(seven);
+    json_decref(array);
+}
+
+static void test_clear(void) {
+    json_t *array, *five, *seven;
+    int i;
+
+    array = json_array();
+    five = json_integer(5);
+    seven = json_integer(7);
+
+    if (!array)
+        fail("unable to create array");
+    if (!five || !seven)
+        fail("unable to create integer");
+
+    for (i = 0; i < 10; i++) {
+        if (json_array_append(array, five))
+            fail("unable to append");
+    }
+    for (i = 0; i < 10; i++) {
+        if (json_array_append(array, seven))
+            fail("unable to append");
+    }
+
+    if (json_array_size(array) != 20)
+        fail("array size is invalid after appending");
+
+    if (json_array_clear(array))
+        fail("unable to clear");
+
+    if (json_array_size(array) != 0)
+        fail("array size is invalid after clearing");
+
+    json_decref(five);
+    json_decref(seven);
+    json_decref(array);
+}
+
+static void test_extend(void) {
+    json_t *array1, *array2, *five, *seven;
+    int i;
+
+    array1 = json_array();
+    array2 = json_array();
+    five = json_integer(5);
+    seven = json_integer(7);
+
+    if (!array1 || !array2)
+        fail("unable to create array");
+    if (!five || !seven)
+        fail("unable to create integer");
+
+    for (i = 0; i < 10; i++) {
+        if (json_array_append(array1, five))
+            fail("unable to append");
+    }
+    for (i = 0; i < 10; i++) {
+        if (json_array_append(array2, seven))
+            fail("unable to append");
+    }
+
+    if (json_array_size(array1) != 10 || json_array_size(array2) != 10)
+        fail("array size is invalid after appending");
+
+    if (json_array_extend(array1, array2))
+        fail("unable to extend");
+
+    for (i = 0; i < 10; i++) {
+        if (json_array_get(array1, i) != five)
+            fail("invalid array contents after extending");
+    }
+    for (i = 10; i < 20; i++) {
+        if (json_array_get(array1, i) != seven)
+            fail("invalid array contents after extending");
+    }
+
+    json_decref(five);
+    json_decref(seven);
+    json_decref(array1);
+    json_decref(array2);
+}
+
+static void test_circular() {
+    json_t *array1, *array2;
+
+    /* the simple cases are checked */
+
+    array1 = json_array();
+    if (!array1)
+        fail("unable to create array");
+
+    if (json_array_append(array1, array1) == 0)
+        fail("able to append self");
+
+    if (json_array_insert(array1, 0, array1) == 0)
+        fail("able to insert self");
+
+    if (json_array_append_new(array1, json_true()))
+        fail("failed to append true");
+
+    if (json_array_set(array1, 0, array1) == 0)
+        fail("able to set self");
+
+    json_decref(array1);
+
+    /* create circular references */
+
+    array1 = json_array();
+    array2 = json_array();
+    if (!array1 || !array2)
+        fail("unable to create array");
+
+    if (json_array_append(array1, array2) || json_array_append(array2, array1))
+        fail("unable to append");
+
+    /* circularity is detected when dumping */
+    if (json_dumps(array1, 0) != NULL)
+        fail("able to dump circulars");
+
+    /* decref twice to deal with the circular references */
+    json_decref(array1);
+    json_decref(array2);
+    json_decref(array1);
+}
+
+static void test_array_foreach() {
+    size_t index;
+    json_t *array1, *array2, *value;
+
+    array1 = json_pack("[sisisi]", "foo", 1, "bar", 2, "baz", 3);
+    array2 = json_array();
+
+    json_array_foreach(array1, index, value) { json_array_append(array2, value); }
+
+    if (!json_equal(array1, array2))
+        fail("json_array_foreach failed to iterate all elements");
+
+    json_decref(array1);
+    json_decref(array2);
+}
+
+static void test_bad_args(void) {
+    json_t *arr = json_array();
+    json_t *num = json_integer(1);
+
+    if (!arr || !num)
+        fail("failed to create required objects");
+
+    if (json_array_size(NULL) != 0)
+        fail("NULL array has nonzero size");
+    if (json_array_size(num) != 0)
+        fail("non-array has nonzero array size");
+
+    if (json_array_get(NULL, 0))
+        fail("json_array_get did not return NULL for non-array");
+    if (json_array_get(num, 0))
+        fail("json_array_get did not return NULL for non-array");
+
+    if (!json_array_set_new(NULL, 0, json_incref(num)))
+        fail("json_array_set_new did not return error for non-array");
+    if (!json_array_set_new(num, 0, json_incref(num)))
+        fail("json_array_set_new did not return error for non-array");
+    if (!json_array_set_new(arr, 0, NULL))
+        fail("json_array_set_new did not return error for NULL value");
+    if (!json_array_set_new(arr, 0, json_incref(arr)))
+        fail("json_array_set_new did not return error for value == array");
+
+    if (!json_array_remove(NULL, 0))
+        fail("json_array_remove did not return error for non-array");
+    if (!json_array_remove(num, 0))
+        fail("json_array_remove did not return error for non-array");
+
+    if (!json_array_clear(NULL))
+        fail("json_array_clear did not return error for non-array");
+    if (!json_array_clear(num))
+        fail("json_array_clear did not return error for non-array");
+
+    if (!json_array_append_new(NULL, json_incref(num)))
+        fail("json_array_append_new did not return error for non-array");
+    if (!json_array_append_new(num, json_incref(num)))
+        fail("json_array_append_new did not return error for non-array");
+    if (!json_array_append_new(arr, NULL))
+        fail("json_array_append_new did not return error for NULL value");
+    if (!json_array_append_new(arr, json_incref(arr)))
+        fail("json_array_append_new did not return error for value == array");
+
+    if (!json_array_insert_new(NULL, 0, json_incref(num)))
+        fail("json_array_insert_new did not return error for non-array");
+    if (!json_array_insert_new(num, 0, json_incref(num)))
+        fail("json_array_insert_new did not return error for non-array");
+    if (!json_array_insert_new(arr, 0, NULL))
+        fail("json_array_insert_new did not return error for NULL value");
+    if (!json_array_insert_new(arr, 0, json_incref(arr)))
+        fail("json_array_insert_new did not return error for value == array");
+
+    if (!json_array_extend(NULL, arr))
+        fail("json_array_extend did not return error for first argument "
+             "non-array");
+    if (!json_array_extend(num, arr))
+        fail("json_array_extend did not return error for first argument "
+             "non-array");
+    if (!json_array_extend(arr, NULL))
+        fail("json_array_extend did not return error for second argument "
+             "non-array");
+    if (!json_array_extend(arr, num))
+        fail("json_array_extend did not return error for second argument "
+             "non-array");
+
+    if (num->refcount != 1)
+        fail("unexpected reference count on num");
+    if (arr->refcount != 1)
+        fail("unexpected reference count on arr");
+
+    json_decref(num);
+    json_decref(arr);
+}
+
+static void run_tests() {
+    test_misc();
+    test_insert();
+    test_remove();
+    test_clear();
+    test_extend();
+    test_circular();
+    test_array_foreach();
+    test_bad_args();
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_chaos.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_chaos.c
new file mode 100644
index 000000000..8687243ed
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_chaos.c
@@ -0,0 +1,168 @@
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include "util.h"
+#include <jansson.h>
+#include <stdio.h>
+#include <string.h>
+
+static int chaos_pos = 0;
+static int chaos_fail = 0;
+#define CHAOS_MAX_FAILURE 100
+
+void *chaos_malloc(size_t size) {
+    if (chaos_pos == chaos_fail)
+        return NULL;
+
+    chaos_pos++;
+
+    return malloc(size);
+}
+
+void chaos_free(void *obj) { free(obj); }
+
+/* Test all potential allocation failures. */
+#define chaos_loop(condition, code, cleanup)                                             \
+    {                                                                                    \
+        chaos_pos = chaos_fail = 0;                                                      \
+        while (condition) {                                                              \
+            if (chaos_fail > CHAOS_MAX_FAILURE)                                          \
+                fail("too many chaos failures");                                         \
+            code chaos_pos = 0;                                                          \
+            chaos_fail++;                                                                \
+        }                                                                                \
+        cleanup                                                                          \
+    }
+
+#define chaos_loop_new_value(json, initcall)                                             \
+    chaos_loop(!json, json = initcall;, json_decref(json); json = NULL;)
+
+int test_unpack() {
+    int ret = -1;
+    int v1;
+    int v2;
+    json_error_t error;
+    json_t *root = json_pack("{s:i, s:i, s:i, s:i}", "n1", 1, "n2", 2, "n3", 3, "n4", 4);
+
+    if (!root)
+        return -1;
+
+    if (!json_unpack_ex(root, &error, JSON_STRICT, "{s:i, s:i}", "n1", &v1, "n2", &v2))
+        fail("Unexpected success");
+
+    if (json_error_code(&error) != json_error_end_of_input_expected) {
+        if (json_error_code(&error) != json_error_out_of_memory)
+            fail("Unexpected error code");
+
+        goto out;
+    }
+
+    if (strcmp(error.text, "2 object item(s) left unpacked: n3, n4"))
+        goto out;
+
+    ret = 0;
+
+out:
+    json_decref(root);
+    return ret;
+}
+
+int dump_chaos_callback(const char *buffer, size_t size, void *data) {
+    json_t *obj = json_object();
+
+    (void)buffer;
+    (void)size;
+    (void)data;
+
+    if (!obj)
+        return -1;
+
+    json_decref(obj);
+
+    return 0;
+}
+
+static void test_chaos() {
+    json_malloc_t orig_malloc;
+    json_free_t orig_free;
+    json_t *json = NULL;
+    json_t *obj = json_object();
+    json_t *arr1 = json_array();
+    json_t *arr2 = json_array();
+    json_t *txt = json_string("test");
+    json_t *intnum = json_integer(1);
+    json_t *dblnum = json_real(0.5);
+    char *dumptxt = NULL;
+    json_t *dumpobj = json_pack("{s:[iiis], s:s}", "key1", 1, 2, 3, "txt", "key2", "v2");
+    int keyno;
+
+    if (!obj || !arr1 || !arr2 || !txt || !intnum || !dblnum || !dumpobj)
+        fail("failed to allocate basic objects");
+
+    json_get_alloc_funcs(&orig_malloc, &orig_free);
+    json_set_alloc_funcs(chaos_malloc, chaos_free);
+
+    chaos_loop_new_value(json, json_pack("{s:s}", "key", "value"));
+    chaos_loop_new_value(json, json_pack("{s:[]}", "key"));
+    chaos_loop_new_value(json, json_pack("[biIf]", 1, 1, (json_int_t)1, 1.0));
+    chaos_loop_new_value(json, json_pack("[s*,s*]", "v1", "v2"));
+    chaos_loop_new_value(json, json_pack("o", json_incref(txt)));
+    chaos_loop_new_value(json, json_pack("O", txt));
+    chaos_loop_new_value(json, json_pack("s++", "a", "long string to force realloc",
+                                         "another long string to force yet another "
+                                         "reallocation of the string because "
+                                         "that's what we are testing."));
+
+    chaos_loop(test_unpack(), , );
+
+    chaos_loop(json_dump_callback(dumpobj, dump_chaos_callback, NULL, JSON_INDENT(1)),
+               , );
+    chaos_loop(json_dump_callback(dumpobj, dump_chaos_callback, NULL,
+                                  JSON_INDENT(1) | JSON_SORT_KEYS),
+               , );
+    chaos_loop(!dumptxt, dumptxt = json_dumps(dumpobj, JSON_COMPACT);, free(dumptxt);
+               dumptxt = NULL;);
+
+    chaos_loop_new_value(json, json_copy(obj));
+    chaos_loop_new_value(json, json_deep_copy(obj));
+
+    chaos_loop_new_value(json, json_copy(arr1));
+    chaos_loop_new_value(json, json_deep_copy(arr1));
+
+    chaos_loop_new_value(json, json_copy(txt));
+    chaos_loop_new_value(json, json_copy(intnum));
+    chaos_loop_new_value(json, json_copy(dblnum));
+
+#define JSON_LOAD_TXT "{\"n\":[1,2,3,4,5,6,7,8,9,10]}"
+    chaos_loop_new_value(json, json_loads(JSON_LOAD_TXT, 0, NULL));
+    chaos_loop_new_value(json, json_loadb(JSON_LOAD_TXT, strlen(JSON_LOAD_TXT), 0, NULL));
+
+    chaos_loop_new_value(json, json_sprintf("%s", "string"));
+
+    for (keyno = 0; keyno < 100; ++keyno) {
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+        /* Skip this test on old Windows compilers. */
+        char testkey[10];
+
+        snprintf(testkey, sizeof(testkey), "test%d", keyno);
+        chaos_loop(json_object_set_new_nocheck(obj, testkey, json_object()), , );
+#endif
+        chaos_loop(json_array_append_new(arr1, json_null()), , );
+        chaos_loop(json_array_insert_new(arr2, 0, json_null()), , );
+    }
+
+    chaos_loop(json_array_extend(arr1, arr2), , );
+    chaos_loop(json_string_set_nocheck(txt, "test"), , );
+
+    json_set_alloc_funcs(orig_malloc, orig_free);
+    json_decref(obj);
+    json_decref(arr1);
+    json_decref(arr2);
+    json_decref(txt);
+    json_decref(intnum);
+    json_decref(dblnum);
+    json_decref(dumpobj);
+}
+
+static void run_tests() { test_chaos(); }
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_copy.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_copy.c
new file mode 100644
index 000000000..656d98dd7
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_copy.c
@@ -0,0 +1,375 @@
+/*
+ * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "util.h"
+#include <jansson.h>
+#include <string.h>
+
+static void test_copy_simple(void) {
+    json_t *value, *copy;
+
+    if (json_copy(NULL))
+        fail("copying NULL doesn't return NULL");
+
+    /* true */
+    value = json_true();
+    copy = json_copy(value);
+    if (value != copy)
+        fail("copying true failed");
+    json_decref(value);
+    json_decref(copy);
+
+    /* false */
+    value = json_false();
+    copy = json_copy(value);
+    if (value != copy)
+        fail("copying false failed");
+    json_decref(value);
+    json_decref(copy);
+
+    /* null */
+    value = json_null();
+    copy = json_copy(value);
+    if (value != copy)
+        fail("copying null failed");
+    json_decref(value);
+    json_decref(copy);
+
+    /* string */
+    value = json_string("foo");
+    if (!value)
+        fail("unable to create a string");
+    copy = json_copy(value);
+    if (!copy)
+        fail("unable to copy a string");
+    if (copy == value)
+        fail("copying a string doesn't copy");
+    if (!json_equal(copy, value))
+        fail("copying a string produces an inequal copy");
+    if (value->refcount != 1 || copy->refcount != 1)
+        fail("invalid refcounts");
+    json_decref(value);
+    json_decref(copy);
+
+    /* integer */
+    value = json_integer(543);
+    if (!value)
+        fail("unable to create an integer");
+    copy = json_copy(value);
+    if (!copy)
+        fail("unable to copy an integer");
+    if (copy == value)
+        fail("copying an integer doesn't copy");
+    if (!json_equal(copy, value))
+        fail("copying an integer produces an inequal copy");
+    if (value->refcount != 1 || copy->refcount != 1)
+        fail("invalid refcounts");
+    json_decref(value);
+    json_decref(copy);
+
+    /* real */
+    value = json_real(123e9);
+    if (!value)
+        fail("unable to create a real");
+    copy = json_copy(value);
+    if (!copy)
+        fail("unable to copy a real");
+    if (copy == value)
+        fail("copying a real doesn't copy");
+    if (!json_equal(copy, value))
+        fail("copying a real produces an inequal copy");
+    if (value->refcount != 1 || copy->refcount != 1)
+        fail("invalid refcounts");
+    json_decref(value);
+    json_decref(copy);
+}
+
+static void test_deep_copy_simple(void) {
+    json_t *value, *copy;
+
+    if (json_deep_copy(NULL))
+        fail("deep copying NULL doesn't return NULL");
+
+    /* true */
+    value = json_true();
+    copy = json_deep_copy(value);
+    if (value != copy)
+        fail("deep copying true failed");
+    json_decref(value);
+    json_decref(copy);
+
+    /* false */
+    value = json_false();
+    copy = json_deep_copy(value);
+    if (value != copy)
+        fail("deep copying false failed");
+    json_decref(value);
+    json_decref(copy);
+
+    /* null */
+    value = json_null();
+    copy = json_deep_copy(value);
+    if (value != copy)
+        fail("deep copying null failed");
+    json_decref(value);
+    json_decref(copy);
+
+    /* string */
+    value = json_string("foo");
+    if (!value)
+        fail("unable to create a string");
+    copy = json_deep_copy(value);
+    if (!copy)
+        fail("unable to deep copy a string");
+    if (copy == value)
+        fail("deep copying a string doesn't copy");
+    if (!json_equal(copy, value))
+        fail("deep copying a string produces an inequal copy");
+    if (value->refcount != 1 || copy->refcount != 1)
+        fail("invalid refcounts");
+    json_decref(value);
+    json_decref(copy);
+
+    /* integer */
+    value = json_integer(543);
+    if (!value)
+        fail("unable to create an integer");
+    copy = json_deep_copy(value);
+    if (!copy)
+        fail("unable to deep copy an integer");
+    if (copy == value)
+        fail("deep copying an integer doesn't copy");
+    if (!json_equal(copy, value))
+        fail("deep copying an integer produces an inequal copy");
+    if (value->refcount != 1 || copy->refcount != 1)
+        fail("invalid refcounts");
+    json_decref(value);
+    json_decref(copy);
+
+    /* real */
+    value = json_real(123e9);
+    if (!value)
+        fail("unable to create a real");
+    copy = json_deep_copy(value);
+    if (!copy)
+        fail("unable to deep copy a real");
+    if (copy == value)
+        fail("deep copying a real doesn't copy");
+    if (!json_equal(copy, value))
+        fail("deep copying a real produces an inequal copy");
+    if (value->refcount != 1 || copy->refcount != 1)
+        fail("invalid refcounts");
+    json_decref(value);
+    json_decref(copy);
+}
+
+static void test_copy_array(void) {
+    const char *json_array_text = "[1, \"foo\", 3.141592, {\"foo\": \"bar\"}]";
+
+    json_t *array, *copy;
+    size_t i;
+
+    array = json_loads(json_array_text, 0, NULL);
+    if (!array)
+        fail("unable to parse an array");
+
+    copy = json_copy(array);
+    if (!copy)
+        fail("unable to copy an array");
+    if (copy == array)
+        fail("copying an array doesn't copy");
+    if (!json_equal(copy, array))
+        fail("copying an array produces an inequal copy");
+
+    for (i = 0; i < json_array_size(copy); i++) {
+        if (json_array_get(array, i) != json_array_get(copy, i))
+            fail("copying an array modifies its elements");
+    }
+
+    json_decref(array);
+    json_decref(copy);
+}
+
+static void test_deep_copy_array(void) {
+    const char *json_array_text = "[1, \"foo\", 3.141592, {\"foo\": \"bar\"}]";
+
+    json_t *array, *copy;
+    size_t i;
+
+    array = json_loads(json_array_text, 0, NULL);
+    if (!array)
+        fail("unable to parse an array");
+
+    copy = json_deep_copy(array);
+    if (!copy)
+        fail("unable to deep copy an array");
+    if (copy == array)
+        fail("deep copying an array doesn't copy");
+    if (!json_equal(copy, array))
+        fail("deep copying an array produces an inequal copy");
+
+    for (i = 0; i < json_array_size(copy); i++) {
+        if (json_array_get(array, i) == json_array_get(copy, i))
+            fail("deep copying an array doesn't copy its elements");
+    }
+
+    json_decref(array);
+    json_decref(copy);
+}
+
+static void test_copy_object(void) {
+    const char *json_object_text =
+        "{\"foo\": \"bar\", \"a\": 1, \"b\": 3.141592, \"c\": [1,2,3,4]}";
+
+    const char *keys[] = {"foo", "a", "b", "c"};
+    int i;
+
+    json_t *object, *copy;
+    void *iter;
+
+    object = json_loads(json_object_text, 0, NULL);
+    if (!object)
+        fail("unable to parse an object");
+
+    copy = json_copy(object);
+    if (!copy)
+        fail("unable to copy an object");
+    if (copy == object)
+        fail("copying an object doesn't copy");
+    if (!json_equal(copy, object))
+        fail("copying an object produces an inequal copy");
+
+    i = 0;
+    iter = json_object_iter(object);
+    while (iter) {
+        const char *key;
+        json_t *value1, *value2;
+
+        key = json_object_iter_key(iter);
+        value1 = json_object_iter_value(iter);
+        value2 = json_object_get(copy, key);
+
+        if (value1 != value2)
+            fail("copying an object modifies its items");
+
+        if (strcmp(key, keys[i]) != 0)
+            fail("copying an object doesn't preserve key order");
+
+        iter = json_object_iter_next(object, iter);
+        i++;
+    }
+
+    json_decref(object);
+    json_decref(copy);
+}
+
+static void test_deep_copy_object(void) {
+    const char *json_object_text =
+        "{\"foo\": \"bar\", \"a\": 1, \"b\": 3.141592, \"c\": [1,2,3,4]}";
+
+    const char *keys[] = {"foo", "a", "b", "c"};
+    int i;
+
+    json_t *object, *copy;
+    void *iter;
+
+    object = json_loads(json_object_text, 0, NULL);
+    if (!object)
+        fail("unable to parse an object");
+
+    copy = json_deep_copy(object);
+    if (!copy)
+        fail("unable to deep copy an object");
+    if (copy == object)
+        fail("deep copying an object doesn't copy");
+    if (!json_equal(copy, object))
+        fail("deep copying an object produces an inequal copy");
+
+    i = 0;
+    iter = json_object_iter(object);
+    while (iter) {
+        const char *key;
+        json_t *value1, *value2;
+
+        key = json_object_iter_key(iter);
+        value1 = json_object_iter_value(iter);
+        value2 = json_object_get(copy, key);
+
+        if (value1 == value2)
+            fail("deep copying an object doesn't copy its items");
+
+        if (strcmp(key, keys[i]) != 0)
+            fail("deep copying an object doesn't preserve key order");
+
+        iter = json_object_iter_next(object, iter);
+        i++;
+    }
+
+    json_decref(object);
+    json_decref(copy);
+}
+
+static void test_deep_copy_circular_references(void) {
+    /* Construct a JSON object/array with a circular reference:
+
+      object: {"a": {"b": {"c": <circular reference to $.a>}}}
+      array: [[[<circular reference to the $[0] array>]]]
+
+      Deep copy it, remove the circular reference and deep copy again.
+   */
+
+    json_t *json;
+    json_t *copy;
+
+    json = json_object();
+    json_object_set_new(json, "a", json_object());
+    json_object_set_new(json_object_get(json, "a"), "b", json_object());
+    json_object_set(json_object_get(json_object_get(json, "a"), "b"), "c",
+                    json_object_get(json, "a"));
+
+    copy = json_deep_copy(json);
+    if (copy)
+        fail("json_deep_copy copied a circular reference!");
+
+    json_object_del(json_object_get(json_object_get(json, "a"), "b"), "c");
+
+    copy = json_deep_copy(json);
+    if (!copy)
+        fail("json_deep_copy failed!");
+
+    json_decref(copy);
+    json_decref(json);
+
+    json = json_array();
+    json_array_append_new(json, json_array());
+    json_array_append_new(json_array_get(json, 0), json_array());
+    json_array_append(json_array_get(json_array_get(json, 0), 0),
+                      json_array_get(json, 0));
+
+    copy = json_deep_copy(json);
+    if (copy)
+        fail("json_deep_copy copied a circular reference!");
+
+    json_array_remove(json_array_get(json_array_get(json, 0), 0), 0);
+
+    copy = json_deep_copy(json);
+    if (!copy)
+        fail("json_deep_copy failed!");
+
+    json_decref(copy);
+    json_decref(json);
+}
+
+static void run_tests() {
+    test_copy_simple();
+    test_deep_copy_simple();
+    test_copy_array();
+    test_deep_copy_array();
+    test_copy_object();
+    test_deep_copy_object();
+    test_deep_copy_circular_references();
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_dump.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_dump.c
new file mode 100644
index 000000000..e8cb51962
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_dump.c
@@ -0,0 +1,311 @@
+/*
+ * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "jansson_private_config.h"
+
+#include <jansson.h>
+#include <string.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include "util.h"
+#ifdef __MINGW32__
+#include <fcntl.h>
+#define pipe(fds) _pipe(fds, 1024, _O_BINARY)
+#endif
+
+static int encode_null_callback(const char *buffer, size_t size, void *data) {
+    (void)buffer;
+    (void)size;
+    (void)data;
+    return 0;
+}
+
+static void encode_null() {
+    if (json_dumps(NULL, JSON_ENCODE_ANY) != NULL)
+        fail("json_dumps didn't fail for NULL");
+
+    if (json_dumpb(NULL, NULL, 0, JSON_ENCODE_ANY) != 0)
+        fail("json_dumpb didn't fail for NULL");
+
+    if (json_dumpf(NULL, stderr, JSON_ENCODE_ANY) != -1)
+        fail("json_dumpf didn't fail for NULL");
+
+#ifdef HAVE_UNISTD_H
+    if (json_dumpfd(NULL, STDERR_FILENO, JSON_ENCODE_ANY) != -1)
+        fail("json_dumpfd didn't fail for NULL");
+#endif
+
+    /* Don't test json_dump_file to avoid creating a file */
+
+    if (json_dump_callback(NULL, encode_null_callback, NULL, JSON_ENCODE_ANY) != -1)
+        fail("json_dump_callback didn't fail for NULL");
+}
+
+static void encode_twice() {
+    /* Encode an empty object/array, add an item, encode again */
+
+    json_t *json;
+    char *result;
+
+    json = json_object();
+    result = json_dumps(json, 0);
+    if (!result || strcmp(result, "{}"))
+        fail("json_dumps failed");
+    free(result);
+
+    json_object_set_new(json, "foo", json_integer(5));
+    result = json_dumps(json, 0);
+    if (!result || strcmp(result, "{\"foo\": 5}"))
+        fail("json_dumps failed");
+    free(result);
+
+    json_decref(json);
+
+    json = json_array();
+    result = json_dumps(json, 0);
+    if (!result || strcmp(result, "[]"))
+        fail("json_dumps failed");
+    free(result);
+
+    json_array_append_new(json, json_integer(5));
+    result = json_dumps(json, 0);
+    if (!result || strcmp(result, "[5]"))
+        fail("json_dumps failed");
+    free(result);
+
+    json_decref(json);
+}
+
+static void circular_references() {
+    /* Construct a JSON object/array with a circular reference:
+
+       object: {"a": {"b": {"c": <circular reference to $.a>}}}
+       array: [[[<circular reference to the $[0] array>]]]
+
+       Encode it, remove the circular reference and encode again.
+    */
+
+    json_t *json;
+    char *result;
+
+    json = json_object();
+    json_object_set_new(json, "a", json_object());
+    json_object_set_new(json_object_get(json, "a"), "b", json_object());
+    json_object_set(json_object_get(json_object_get(json, "a"), "b"), "c",
+                    json_object_get(json, "a"));
+
+    if (json_dumps(json, 0))
+        fail("json_dumps encoded a circular reference!");
+
+    json_object_del(json_object_get(json_object_get(json, "a"), "b"), "c");
+
+    result = json_dumps(json, 0);
+    if (!result || strcmp(result, "{\"a\": {\"b\": {}}}"))
+        fail("json_dumps failed!");
+    free(result);
+
+    json_decref(json);
+
+    json = json_array();
+    json_array_append_new(json, json_array());
+    json_array_append_new(json_array_get(json, 0), json_array());
+    json_array_append(json_array_get(json_array_get(json, 0), 0),
+                      json_array_get(json, 0));
+
+    if (json_dumps(json, 0))
+        fail("json_dumps encoded a circular reference!");
+
+    json_array_remove(json_array_get(json_array_get(json, 0), 0), 0);
+
+    result = json_dumps(json, 0);
+    if (!result || strcmp(result, "[[[]]]"))
+        fail("json_dumps failed!");
+    free(result);
+
+    json_decref(json);
+}
+
+static void encode_other_than_array_or_object() {
+    /* Encoding anything other than array or object should only
+     * succeed if the JSON_ENCODE_ANY flag is used */
+
+    json_t *json;
+    char *result;
+
+    json = json_string("foo");
+    if (json_dumps(json, 0) != NULL)
+        fail("json_dumps encoded a string!");
+    if (json_dumpf(json, NULL, 0) == 0)
+        fail("json_dumpf encoded a string!");
+    if (json_dumpfd(json, -1, 0) == 0)
+        fail("json_dumpfd encoded a string!");
+
+    result = json_dumps(json, JSON_ENCODE_ANY);
+    if (!result || strcmp(result, "\"foo\"") != 0)
+        fail("json_dumps failed to encode a string with JSON_ENCODE_ANY");
+
+    free(result);
+    json_decref(json);
+
+    json = json_integer(42);
+    if (json_dumps(json, 0) != NULL)
+        fail("json_dumps encoded an integer!");
+    if (json_dumpf(json, NULL, 0) == 0)
+        fail("json_dumpf encoded an integer!");
+    if (json_dumpfd(json, -1, 0) == 0)
+        fail("json_dumpfd encoded an integer!");
+
+    result = json_dumps(json, JSON_ENCODE_ANY);
+    if (!result || strcmp(result, "42") != 0)
+        fail("json_dumps failed to encode an integer with JSON_ENCODE_ANY");
+
+    free(result);
+    json_decref(json);
+}
+
+static void escape_slashes() {
+    /* Test dump escaping slashes */
+
+    json_t *json;
+    char *result;
+
+    json = json_object();
+    json_object_set_new(json, "url", json_string("https://github.com/akheron/jansson"));
+
+    result = json_dumps(json, 0);
+    if (!result || strcmp(result, "{\"url\": \"https://github.com/akheron/jansson\"}"))
+        fail("json_dumps failed to not escape slashes");
+
+    free(result);
+
+    result = json_dumps(json, JSON_ESCAPE_SLASH);
+    if (!result ||
+        strcmp(result, "{\"url\": \"https:\\/\\/github.com\\/akheron\\/jansson\"}"))
+        fail("json_dumps failed to escape slashes");
+
+    free(result);
+    json_decref(json);
+}
+
+static void encode_nul_byte() {
+    json_t *json;
+    char *result;
+
+    json = json_stringn("nul byte \0 in string", 20);
+    result = json_dumps(json, JSON_ENCODE_ANY);
+    if (!result || memcmp(result, "\"nul byte \\u0000 in string\"", 27))
+        fail("json_dumps failed to dump an embedded NUL byte");
+
+    free(result);
+    json_decref(json);
+}
+
+static void dump_file() {
+    json_t *json;
+    int result;
+
+    result = json_dump_file(NULL, "", 0);
+    if (result != -1)
+        fail("json_dump_file succeeded with invalid args");
+
+    json = json_object();
+    result = json_dump_file(json, "json_dump_file.json", 0);
+    if (result != 0)
+        fail("json_dump_file failed");
+
+    json_decref(json);
+    remove("json_dump_file.json");
+}
+
+static void dumpb() {
+    char buf[2];
+    json_t *obj;
+    size_t size;
+
+    obj = json_object();
+
+    size = json_dumpb(obj, buf, sizeof(buf), 0);
+    if (size != 2 || strncmp(buf, "{}", 2))
+        fail("json_dumpb failed");
+
+    json_decref(obj);
+    obj = json_pack("{s:s}", "foo", "bar");
+
+    size = json_dumpb(obj, buf, sizeof(buf), JSON_COMPACT);
+    if (size != 13)
+        fail("json_dumpb size check failed");
+
+    json_decref(obj);
+}
+
+static void dumpfd() {
+#ifdef HAVE_UNISTD_H
+    int fds[2] = {-1, -1};
+    json_t *a, *b;
+
+    if (pipe(fds))
+        fail("pipe() failed");
+
+    a = json_pack("{s:s}", "foo", "bar");
+
+    if (json_dumpfd(a, fds[1], 0))
+        fail("json_dumpfd() failed");
+    close(fds[1]);
+
+    b = json_loadfd(fds[0], 0, NULL);
+    if (!b)
+        fail("json_loadfd() failed");
+    close(fds[0]);
+
+    if (!json_equal(a, b))
+        fail("json_equal() failed for fd test");
+
+    json_decref(a);
+    json_decref(b);
+#endif
+}
+
+static void embed() {
+    static const char *plains[] = {"{\"bar\":[],\"foo\":{}}", "[[],{}]", "{}", "[]",
+                                   NULL};
+
+    size_t i;
+
+    for (i = 0; plains[i]; i++) {
+        const char *plain = plains[i];
+        json_t *parse = NULL;
+        char *embed = NULL;
+        size_t psize = 0;
+        size_t esize = 0;
+
+        psize = strlen(plain) - 2;
+        embed = calloc(1, psize);
+        parse = json_loads(plain, 0, NULL);
+        esize =
+            json_dumpb(parse, embed, psize, JSON_COMPACT | JSON_SORT_KEYS | JSON_EMBED);
+        json_decref(parse);
+        if (esize != psize)
+            fail("json_dumpb(JSON_EMBED) returned an invalid size");
+        if (strncmp(plain + 1, embed, esize) != 0)
+            fail("json_dumps(JSON_EMBED) returned an invalid value");
+        free(embed);
+    }
+}
+
+static void run_tests() {
+    encode_null();
+    encode_twice();
+    circular_references();
+    encode_other_than_array_or_object();
+    escape_slashes();
+    encode_nul_byte();
+    dump_file();
+    dumpb();
+    dumpfd();
+    embed();
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_dump_callback.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_dump_callback.c
new file mode 100644
index 000000000..80ea00845
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_dump_callback.c
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "util.h"
+#include <jansson.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct my_sink {
+    char *buf;
+    size_t off;
+    size_t cap;
+};
+
+static int my_writer(const char *buffer, size_t len, void *data) {
+    struct my_sink *s = data;
+    if (len > s->cap - s->off) {
+        return -1;
+    }
+    memcpy(s->buf + s->off, buffer, len);
+    s->off += len;
+    return 0;
+}
+
+static void run_tests() {
+    struct my_sink s;
+    json_t *json;
+    const char str[] = "[\"A\", {\"B\": \"C\", \"e\": false}, 1, null, \"foo\"]";
+    char *dumped_to_string;
+
+    json = json_loads(str, 0, NULL);
+    if (!json) {
+        fail("json_loads failed");
+    }
+
+    dumped_to_string = json_dumps(json, 0);
+    if (!dumped_to_string) {
+        json_decref(json);
+        fail("json_dumps failed");
+    }
+
+    s.off = 0;
+    s.cap = strlen(dumped_to_string);
+    s.buf = malloc(s.cap);
+    if (!s.buf) {
+        json_decref(json);
+        free(dumped_to_string);
+        fail("malloc failed");
+    }
+
+    if (json_dump_callback(json, my_writer, &s, 0) == -1) {
+        json_decref(json);
+        free(dumped_to_string);
+        free(s.buf);
+        fail("json_dump_callback failed on an exact-length sink buffer");
+    }
+
+    if (strncmp(dumped_to_string, s.buf, s.off) != 0) {
+        json_decref(json);
+        free(dumped_to_string);
+        free(s.buf);
+        fail("json_dump_callback and json_dumps did not produce identical "
+             "output");
+    }
+
+    s.off = 1;
+    if (json_dump_callback(json, my_writer, &s, 0) != -1) {
+        json_decref(json);
+        free(dumped_to_string);
+        free(s.buf);
+        fail("json_dump_callback succeeded on a short buffer when it should "
+             "have failed");
+    }
+
+    json_decref(json);
+    free(dumped_to_string);
+    free(s.buf);
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_equal.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_equal.c
new file mode 100644
index 000000000..d068b7bf8
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_equal.c
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "util.h"
+#include <jansson.h>
+
+static void test_equal_simple() {
+    json_t *value1, *value2;
+
+    if (json_equal(NULL, NULL))
+        fail("json_equal fails for two NULLs");
+
+    value1 = json_true();
+    if (json_equal(value1, NULL) || json_equal(NULL, value1))
+        fail("json_equal fails for NULL");
+
+    /* this covers true, false and null as they are singletons */
+    if (!json_equal(value1, value1))
+        fail("identical objects are not equal");
+    json_decref(value1);
+
+    /* integer */
+    value1 = json_integer(1);
+    value2 = json_integer(1);
+    if (!value1 || !value2)
+        fail("unable to create integers");
+    if (!json_equal(value1, value2))
+        fail("json_equal fails for two equal integers");
+    json_decref(value2);
+
+    value2 = json_integer(2);
+    if (!value2)
+        fail("unable to create an integer");
+    if (json_equal(value1, value2))
+        fail("json_equal fails for two inequal integers");
+
+    json_decref(value1);
+    json_decref(value2);
+
+    /* real */
+    value1 = json_real(1.2);
+    value2 = json_real(1.2);
+    if (!value1 || !value2)
+        fail("unable to create reals");
+    if (!json_equal(value1, value2))
+        fail("json_equal fails for two equal reals");
+    json_decref(value2);
+
+    value2 = json_real(3.141592);
+    if (!value2)
+        fail("unable to create an real");
+    if (json_equal(value1, value2))
+        fail("json_equal fails for two inequal reals");
+
+    json_decref(value1);
+    json_decref(value2);
+
+    /* string */
+    value1 = json_string("foo");
+    value2 = json_string("foo");
+    if (!value1 || !value2)
+        fail("unable to create strings");
+    if (!json_equal(value1, value2))
+        fail("json_equal fails for two equal strings");
+    json_decref(value2);
+
+    value2 = json_string("bar");
+    if (!value2)
+        fail("unable to create an string");
+    if (json_equal(value1, value2))
+        fail("json_equal fails for two inequal strings");
+    json_decref(value2);
+
+    value2 = json_string("bar2");
+    if (!value2)
+        fail("unable to create an string");
+    if (json_equal(value1, value2))
+        fail("json_equal fails for two inequal length strings");
+
+    json_decref(value1);
+    json_decref(value2);
+}
+
+static void test_equal_array() {
+    json_t *array1, *array2;
+
+    array1 = json_array();
+    array2 = json_array();
+    if (!array1 || !array2)
+        fail("unable to create arrays");
+
+    if (!json_equal(array1, array2))
+        fail("json_equal fails for two empty arrays");
+
+    json_array_append_new(array1, json_integer(1));
+    json_array_append_new(array2, json_integer(1));
+    json_array_append_new(array1, json_string("foo"));
+    json_array_append_new(array2, json_string("foo"));
+    json_array_append_new(array1, json_integer(2));
+    json_array_append_new(array2, json_integer(2));
+    if (!json_equal(array1, array2))
+        fail("json_equal fails for two equal arrays");
+
+    json_array_remove(array2, 2);
+    if (json_equal(array1, array2))
+        fail("json_equal fails for two inequal arrays");
+
+    json_array_append_new(array2, json_integer(3));
+    if (json_equal(array1, array2))
+        fail("json_equal fails for two inequal arrays");
+
+    json_decref(array1);
+    json_decref(array2);
+}
+
+static void test_equal_object() {
+    json_t *object1, *object2;
+
+    object1 = json_object();
+    object2 = json_object();
+    if (!object1 || !object2)
+        fail("unable to create objects");
+
+    if (!json_equal(object1, object2))
+        fail("json_equal fails for two empty objects");
+
+    json_object_set_new(object1, "a", json_integer(1));
+    json_object_set_new(object2, "a", json_integer(1));
+    json_object_set_new(object1, "b", json_string("foo"));
+    json_object_set_new(object2, "b", json_string("foo"));
+    json_object_set_new(object1, "c", json_integer(2));
+    json_object_set_new(object2, "c", json_integer(2));
+    if (!json_equal(object1, object2))
+        fail("json_equal fails for two equal objects");
+
+    json_object_del(object2, "c");
+    if (json_equal(object1, object2))
+        fail("json_equal fails for two inequal objects");
+
+    json_object_set_new(object2, "c", json_integer(3));
+    if (json_equal(object1, object2))
+        fail("json_equal fails for two inequal objects");
+
+    json_object_del(object2, "c");
+    json_object_set_new(object2, "d", json_integer(2));
+    if (json_equal(object1, object2))
+        fail("json_equal fails for two inequal objects");
+
+    json_decref(object1);
+    json_decref(object2);
+}
+
+static void test_equal_complex() {
+    json_t *value1, *value2, *value3;
+
+    const char *complex_json = "{"
+                               "    \"integer\": 1, "
+                               "    \"real\": 3.141592, "
+                               "    \"string\": \"foobar\", "
+                               "    \"true\": true, "
+                               "    \"object\": {"
+                               "        \"array-in-object\": [1,true,\"foo\",{}],"
+                               "        \"object-in-object\": {\"foo\": \"bar\"}"
+                               "    },"
+                               "    \"array\": [\"foo\", false, null, 1.234]"
+                               "}";
+
+    value1 = json_loads(complex_json, 0, NULL);
+    value2 = json_loads(complex_json, 0, NULL);
+    value3 = json_loads(complex_json, 0, NULL);
+    if (!value1 || !value2)
+        fail("unable to parse JSON");
+    if (!json_equal(value1, value2))
+        fail("json_equal fails for two equal objects");
+
+    json_array_set_new(
+        json_object_get(json_object_get(value2, "object"), "array-in-object"), 1,
+        json_false());
+    if (json_equal(value1, value2))
+        fail("json_equal fails for two inequal objects");
+
+    json_object_set_new(
+        json_object_get(json_object_get(value3, "object"), "object-in-object"), "foo",
+        json_string("baz"));
+    if (json_equal(value1, value3))
+        fail("json_equal fails for two inequal objects");
+
+    json_decref(value1);
+    json_decref(value2);
+    json_decref(value3);
+}
+
+static void run_tests() {
+    test_equal_simple();
+    test_equal_array();
+    test_equal_object();
+    test_equal_complex();
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_fixed_size.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_fixed_size.c
new file mode 100644
index 000000000..4ae9e079c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_fixed_size.c
@@ -0,0 +1,228 @@
+/*
+ * Copyright (c) 2020 Petri Lehtinen <petri@digip.org>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "util.h"
+#include <jansson.h>
+#include <string.h>
+
+static void test_keylen_iterator(json_t *object) {
+    const char key1[] = {'t', 'e', 's', 't', '1'};
+    const char key2[] = {'t', 'e', 's', 't'};
+    const char key3[] = {'t', 'e', 's', '\0', 't'};
+    const char key4[] = {'t', 'e', 's', 't', '\0'};
+    const char *reference_keys[] = {key1, key2, key3, key4};
+    const size_t reference_keys_len[] = {sizeof(key1), sizeof(key2), sizeof(key3),
+                                         sizeof(key4)};
+    size_t index = 0;
+    json_t *value;
+    const char *key;
+    size_t keylen;
+
+    json_object_keylen_foreach(object, key, keylen, value) {
+        if (keylen != reference_keys_len[index])
+            fail("invalid key len in iterator");
+        if (memcmp(key, reference_keys[index], reference_keys_len[index]) != 0)
+            fail("invalid key in iterator");
+
+        index++;
+    }
+}
+
+static void test_keylen(void) {
+    json_t *obj = json_object();
+    const char key[] = {'t', 'e', 's', 't', '1'};
+    const char key2[] = {'t', 'e', 's', 't'};
+    const char key3[] = {'t', 'e', 's', '\0', 't'};
+    const char key4[] = {'t', 'e', 's', 't', '\0'};
+
+    if (json_object_size(obj) != 0)
+        fail("incorrect json");
+
+    json_object_set_new_nocheck(obj, "test1", json_true());
+
+    if (json_object_size(obj) != 1)
+        fail("incorrect json");
+
+    if (json_object_getn(obj, key, sizeof(key)) != json_true())
+        fail("json_object_getn failed");
+
+    if (json_object_getn(obj, key2, sizeof(key2)) != NULL)
+        fail("false positive json_object_getn by key2");
+
+    if (json_object_setn_nocheck(obj, key2, sizeof(key2), json_false()))
+        fail("json_object_setn_nocheck for key2 failed");
+
+    if (json_object_size(obj) != 2)
+        fail("incorrect json");
+
+    if (json_object_get(obj, "test") != json_false())
+        fail("json_object_setn_nocheck for key2 failed");
+
+    if (json_object_getn(obj, key2, sizeof(key2)) != json_false())
+        fail("json_object_getn by key 2 failed");
+
+    if (json_object_getn(obj, key3, sizeof(key3)) != NULL)
+        fail("false positive json_object_getn by key3");
+
+    if (json_object_setn_nocheck(obj, key3, sizeof(key3), json_false()))
+        fail("json_object_setn_nocheck for key3 failed");
+
+    if (json_object_size(obj) != 3)
+        fail("incorrect json");
+
+    if (json_object_getn(obj, key3, sizeof(key3)) != json_false())
+        fail("json_object_getn by key 3 failed");
+
+    if (json_object_getn(obj, key4, sizeof(key4)) != NULL)
+        fail("false positive json_object_getn by key3");
+
+    if (json_object_setn_nocheck(obj, key4, sizeof(key4), json_false()))
+        fail("json_object_setn_nocheck for key3 failed");
+
+    if (json_object_size(obj) != 4)
+        fail("incorrect json");
+
+    test_keylen_iterator(obj);
+
+    if (json_object_getn(obj, key4, sizeof(key4)) != json_false())
+        fail("json_object_getn by key 3 failed");
+
+    if (json_object_size(obj) != 4)
+        fail("incorrect json");
+
+    if (json_object_deln(obj, key4, sizeof(key4)))
+        fail("json_object_deln failed");
+    if (json_object_getn(obj, key4, sizeof(key4)) != NULL)
+        fail("json_object_deln failed");
+    if (json_object_size(obj) != 3)
+        fail("incorrect json");
+
+    if (json_object_deln(obj, key3, sizeof(key3)))
+        fail("json_object_deln failed");
+    if (json_object_getn(obj, key3, sizeof(key3)) != NULL)
+        fail("json_object_deln failed");
+    if (json_object_size(obj) != 2)
+        fail("incorrect json");
+
+    if (json_object_deln(obj, key2, sizeof(key2)))
+        fail("json_object_deln failed");
+    if (json_object_getn(obj, key2, sizeof(key2)) != NULL)
+        fail("json_object_deln failed");
+    if (json_object_size(obj) != 1)
+        fail("incorrect json");
+
+    if (json_object_deln(obj, key, sizeof(key)))
+        fail("json_object_deln failed");
+    if (json_object_getn(obj, key, sizeof(key)) != NULL)
+        fail("json_object_deln failed");
+    if (json_object_size(obj) != 0)
+        fail("incorrect json");
+
+    json_decref(obj);
+}
+
+static void test_invalid_keylen(void) {
+    json_t *obj = json_object();
+    json_t *empty_obj = json_object();
+    const char key[] = {'t', 'e', 's', 't', '1'};
+
+    json_object_set_new_nocheck(obj, "test1", json_true());
+
+    if (json_object_getn(NULL, key, sizeof(key)) != NULL)
+        fail("json_object_getn on NULL failed");
+
+    if (json_object_getn(obj, NULL, sizeof(key)) != NULL)
+        fail("json_object_getn on NULL failed");
+
+    if (json_object_getn(obj, key, 0) != NULL)
+        fail("json_object_getn on NULL failed");
+
+    if (!json_object_setn_new(obj, NULL, sizeof(key), json_true()))
+        fail("json_object_setn_new with NULL key failed");
+
+    if (!json_object_setn_new_nocheck(obj, NULL, sizeof(key), json_true()))
+        fail("json_object_setn_new_nocheck with NULL key failed");
+
+    if (!json_object_del(obj, NULL))
+        fail("json_object_del with NULL failed");
+
+    if (!json_object_deln(empty_obj, key, sizeof(key)))
+        fail("json_object_deln with empty object failed");
+
+    if (!json_object_deln(obj, key, sizeof(key) - 1))
+        fail("json_object_deln with incomplete key failed");
+
+    json_decref(obj);
+    json_decref(empty_obj);
+}
+
+static void test_binary_keys(void) {
+    json_t *obj = json_object();
+    int key1 = 0;
+    int key2 = 1;
+
+    json_object_setn_nocheck(obj, (const char *)&key1, sizeof(key1), json_true());
+    json_object_setn_nocheck(obj, (const char *)&key2, sizeof(key2), json_true());
+
+    if (!json_is_true(json_object_getn(obj, (const char *)&key1, sizeof(key1))))
+        fail("cannot get integer key1");
+
+    if (!json_is_true(json_object_getn(obj, (const char *)&key1, sizeof(key2))))
+        fail("cannot get integer key2");
+
+    if (json_object_size(obj) != 2)
+        fail("binary object size missmatch");
+
+    if (json_object_deln(obj, (const char *)&key1, sizeof(key1)))
+        fail("cannot del integer key1");
+
+    if (json_object_size(obj) != 1)
+        fail("binary object size missmatch");
+
+    if (json_object_deln(obj, (const char *)&key2, sizeof(key2)))
+        fail("cannot del integer key2");
+
+    if (json_object_size(obj) != 0)
+        fail("binary object size missmatch");
+
+    json_decref(obj);
+}
+
+static void test_dump_order(void) {
+    json_t *obj = json_object();
+    char key1[] = {'k', '\0', '-', '2'};
+    char key2[] = {'k', '\0', '-', '1'};
+    const char expected_sorted_str[] =
+        "{\"k\\u0000-1\": \"first\", \"k\\u0000-2\": \"second\"}";
+    const char expected_nonsorted_str[] =
+        "{\"k\\u0000-2\": \"second\", \"k\\u0000-1\": \"first\"}";
+    char *out;
+
+    json_object_setn_new_nocheck(obj, key1, sizeof(key1), json_string("second"));
+    json_object_setn_new_nocheck(obj, key2, sizeof(key2), json_string("first"));
+
+    out = malloc(512);
+
+    json_dumpb(obj, out, 512, 0);
+
+    if (memcmp(expected_nonsorted_str, out, sizeof(expected_nonsorted_str) - 1) != 0)
+        fail("preserve order failed");
+
+    json_dumpb(obj, out, 512, JSON_SORT_KEYS);
+    if (memcmp(expected_sorted_str, out, sizeof(expected_sorted_str) - 1) != 0)
+        fail("utf-8 sort failed");
+
+    free(out);
+    json_decref(obj);
+}
+
+static void run_tests() {
+    test_keylen();
+    test_invalid_keylen();
+    test_binary_keys();
+    test_dump_order();
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_load.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_load.c
new file mode 100644
index 000000000..1c64b0c8d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_load.c
@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "util.h"
+#include <jansson.h>
+#include <string.h>
+
+static void file_not_found() {
+    json_t *json;
+    json_error_t error;
+    char *pos;
+
+    json = json_load_file("/path/to/nonexistent/file.json", 0, &error);
+    if (json)
+        fail("json_load_file returned non-NULL for a nonexistent file");
+    if (error.line != -1)
+        fail("json_load_file returned an invalid line number");
+
+    /* The error message is locale specific, only check the beginning
+       of the error message. */
+
+    pos = strchr(error.text, ':');
+    if (!pos)
+        fail("json_load_file returne an invalid error message");
+
+    *pos = '\0';
+
+    if (strcmp(error.text, "unable to open /path/to/nonexistent/file.json") != 0)
+        fail("json_load_file returned an invalid error message");
+    if (json_error_code(&error) != json_error_cannot_open_file)
+        fail("json_load_file returned an invalid error code");
+}
+
+static void very_long_file_name() {
+    json_t *json;
+    json_error_t error;
+
+    json = json_load_file("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                          "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                          0, &error);
+    if (json)
+        fail("json_load_file returned non-NULL for a nonexistent file");
+    if (error.line != -1)
+        fail("json_load_file returned an invalid line number");
+
+    if (strncmp(error.source, "...aaa", 6) != 0)
+        fail("error source was set incorrectly");
+    if (json_error_code(&error) != json_error_cannot_open_file)
+        fail("error code was set incorrectly");
+}
+
+static void reject_duplicates() {
+    json_error_t error;
+
+    if (json_loads("{\"foo\": 1, \"foo\": 2}", JSON_REJECT_DUPLICATES, &error))
+        fail("json_loads did not detect a duplicate key");
+    check_error(json_error_duplicate_key, "duplicate object key near '\"foo\"'",
+                "<string>", 1, 16, 16);
+}
+
+static void disable_eof_check() {
+    json_error_t error;
+    json_t *json;
+
+    const char *text = "{\"foo\": 1} garbage";
+
+    if (json_loads(text, 0, &error))
+        fail("json_loads did not detect garbage after JSON text");
+    check_error(json_error_end_of_input_expected, "end of file expected near 'garbage'",
+                "<string>", 1, 18, 18);
+
+    json = json_loads(text, JSON_DISABLE_EOF_CHECK, &error);
+    if (!json)
+        fail("json_loads failed with JSON_DISABLE_EOF_CHECK");
+
+    json_decref(json);
+}
+
+static void decode_any() {
+    json_t *json;
+    json_error_t error;
+
+    json = json_loads("\"foo\"", JSON_DECODE_ANY, &error);
+    if (!json || !json_is_string(json))
+        fail("json_load decoded any failed - string");
+    json_decref(json);
+
+    json = json_loads("42", JSON_DECODE_ANY, &error);
+    if (!json || !json_is_integer(json))
+        fail("json_load decoded any failed - integer");
+    json_decref(json);
+
+    json = json_loads("true", JSON_DECODE_ANY, &error);
+    if (!json || !json_is_true(json))
+        fail("json_load decoded any failed - boolean");
+    json_decref(json);
+
+    json = json_loads("null", JSON_DECODE_ANY, &error);
+    if (!json || !json_is_null(json))
+        fail("json_load decoded any failed - null");
+    json_decref(json);
+}
+
+static void decode_int_as_real() {
+    json_t *json;
+    json_error_t error;
+
+#if JSON_INTEGER_IS_LONG_LONG
+    const char *imprecise;
+    json_int_t expected;
+#endif
+
+    char big[311];
+
+    json = json_loads("42", JSON_DECODE_INT_AS_REAL | JSON_DECODE_ANY, &error);
+    if (!json || !json_is_real(json) || json_real_value(json) != 42.0)
+        fail("json_load decode int as real failed - int");
+    json_decref(json);
+
+#if JSON_INTEGER_IS_LONG_LONG
+    /* This number cannot be represented exactly by a double */
+    imprecise = "9007199254740993";
+    expected = 9007199254740992ll;
+
+    json = json_loads(imprecise, JSON_DECODE_INT_AS_REAL | JSON_DECODE_ANY, &error);
+    if (!json || !json_is_real(json) || expected != (json_int_t)json_real_value(json))
+        fail("json_load decode int as real failed - expected imprecision");
+    json_decref(json);
+#endif
+
+    /* 1E309 overflows. Here we create 1E309 as a decimal number, i.e.
+       1000...(309 zeroes)...0. */
+    big[0] = '1';
+    memset(big + 1, '0', 309);
+    big[310] = '\0';
+
+    json = json_loads(big, JSON_DECODE_INT_AS_REAL | JSON_DECODE_ANY, &error);
+    if (json || strcmp(error.text, "real number overflow") != 0 ||
+        json_error_code(&error) != json_error_numeric_overflow)
+        fail("json_load decode int as real failed - expected overflow");
+    json_decref(json);
+}
+
+static void allow_nul() {
+    const char *text = "\"nul byte \\u0000 in string\"";
+    const char *expected = "nul byte \0 in string";
+    size_t len = 20;
+    json_t *json;
+
+    json = json_loads(text, JSON_ALLOW_NUL | JSON_DECODE_ANY, NULL);
+    if (!json || !json_is_string(json))
+        fail("unable to decode embedded NUL byte");
+
+    if (json_string_length(json) != len)
+        fail("decoder returned wrong string length");
+
+    if (memcmp(json_string_value(json), expected, len + 1))
+        fail("decoder returned wrong string content");
+
+    json_decref(json);
+}
+
+static void load_wrong_args() {
+    json_t *json;
+    json_error_t error;
+
+    json = json_loads(NULL, 0, &error);
+    if (json)
+        fail("json_loads should return NULL if the first argument is NULL");
+
+    json = json_loadb(NULL, 0, 0, &error);
+    if (json)
+        fail("json_loadb should return NULL if the first argument is NULL");
+
+    json = json_loadf(NULL, 0, &error);
+    if (json)
+        fail("json_loadf should return NULL if the first argument is NULL");
+
+    json = json_loadfd(-1, 0, &error);
+    if (json)
+        fail("json_loadfd should return NULL if the first argument is < 0");
+
+    json = json_load_file(NULL, 0, &error);
+    if (json)
+        fail("json_load_file should return NULL if the first argument is NULL");
+}
+
+static void position() {
+    json_t *json;
+    size_t flags = JSON_DISABLE_EOF_CHECK;
+    json_error_t error;
+
+    json = json_loads("{\"foo\": \"bar\"}", 0, &error);
+    if (error.position != 14)
+        fail("json_loads returned a wrong position");
+    json_decref(json);
+
+    json = json_loads("{\"foo\": \"bar\"} baz quux", flags, &error);
+    if (error.position != 14)
+        fail("json_loads returned a wrong position");
+    json_decref(json);
+}
+
+static void error_code() {
+    json_error_t error;
+    json_t *json = json_loads("[123] garbage", 0, &error);
+    if (json != NULL)
+        fail("json_loads returned not NULL");
+    if (strlen(error.text) >= JSON_ERROR_TEXT_LENGTH)
+        fail("error.text longer than expected");
+    if (json_error_code(&error) != json_error_end_of_input_expected)
+        fail("json_loads returned incorrect error code");
+
+    json = json_loads("{\"foo\": ", 0, &error);
+    if (json != NULL)
+        fail("json_loads returned not NULL");
+    if (strlen(error.text) >= JSON_ERROR_TEXT_LENGTH)
+        fail("error.text longer than expected");
+    if (json_error_code(&error) != json_error_premature_end_of_input)
+        fail("json_loads returned incorrect error code");
+}
+
+static void run_tests() {
+    file_not_found();
+    very_long_file_name();
+    reject_duplicates();
+    disable_eof_check();
+    decode_any();
+    decode_int_as_real();
+    allow_nul();
+    load_wrong_args();
+    position();
+    error_code();
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_load_callback.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_load_callback.c
new file mode 100644
index 000000000..b292fcf42
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_load_callback.c
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2009-2011 Petri Lehtinen <petri@digip.org>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "util.h"
+#include <jansson.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct my_source {
+    const char *buf;
+    size_t off;
+    size_t cap;
+};
+
+static const char my_str[] = "[\"A\", {\"B\": \"C\", \"e\": false}, 1, null, \"foo\"]";
+
+static size_t greedy_reader(void *buf, size_t buflen, void *arg) {
+    struct my_source *s = arg;
+    if (buflen > s->cap - s->off)
+        buflen = s->cap - s->off;
+    if (buflen > 0) {
+        memcpy(buf, s->buf + s->off, buflen);
+        s->off += buflen;
+        return buflen;
+    } else {
+        return 0;
+    }
+}
+
+static void run_tests() {
+    struct my_source s;
+    json_t *json;
+    json_error_t error;
+
+    s.off = 0;
+    s.cap = strlen(my_str);
+    s.buf = my_str;
+
+    json = json_load_callback(greedy_reader, &s, 0, &error);
+
+    if (!json)
+        fail("json_load_callback failed on a valid callback");
+    json_decref(json);
+
+    s.off = 0;
+    s.cap = strlen(my_str) - 1;
+    s.buf = my_str;
+
+    json = json_load_callback(greedy_reader, &s, 0, &error);
+    if (json) {
+        json_decref(json);
+        fail("json_load_callback should have failed on an incomplete stream, "
+             "but it didn't");
+    }
+    if (strcmp(error.source, "<callback>") != 0) {
+        fail("json_load_callback returned an invalid error source");
+    }
+    if (strcmp(error.text, "']' expected near end of file") != 0) {
+        fail("json_load_callback returned an invalid error message for an "
+             "unclosed top-level array");
+    }
+
+    json = json_load_callback(NULL, NULL, 0, &error);
+    if (json) {
+        json_decref(json);
+        fail("json_load_callback should have failed on NULL load callback, but "
+             "it didn't");
+    }
+    if (strcmp(error.text, "wrong arguments") != 0) {
+        fail("json_load_callback returned an invalid error message for a NULL "
+             "load callback");
+    }
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_loadb.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_loadb.c
new file mode 100644
index 000000000..2cd88fef3
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_loadb.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "util.h"
+#include <jansson.h>
+#include <string.h>
+
+static void run_tests() {
+    json_t *json;
+    json_error_t error;
+    const char str[] = "[\"A\", {\"B\": \"C\"}, 1, 2, 3]garbage";
+    size_t len = strlen(str) - strlen("garbage");
+
+    json = json_loadb(str, len, 0, &error);
+    if (!json) {
+        fail("json_loadb failed on a valid JSON buffer");
+    }
+    json_decref(json);
+
+    json = json_loadb(str, len - 1, 0, &error);
+    if (json) {
+        json_decref(json);
+        fail("json_loadb should have failed on an incomplete buffer, but it "
+             "didn't");
+    }
+    if (error.line != 1) {
+        fail("json_loadb returned an invalid line number on fail");
+    }
+    if (strcmp(error.text, "']' expected near end of file") != 0) {
+        fail("json_loadb returned an invalid error message for an unclosed "
+             "top-level array");
+    }
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_memory_funcs.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_memory_funcs.c
new file mode 100644
index 000000000..4fd616654
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_memory_funcs.c
@@ -0,0 +1,115 @@
+#include <jansson.h>
+#include <string.h>
+
+#include "util.h"
+
+static int malloc_called = 0;
+static int free_called = 0;
+static size_t malloc_used = 0;
+
+/* helpers */
+static void create_and_free_complex_object() {
+    json_t *obj;
+
+    obj = json_pack("{s:i,s:n,s:b,s:b,s:{s:s},s:[i,i,i]}", "foo", 42, "bar", "baz", 1,
+                    "qux", 0, "alice", "bar", "baz", "bob", 9, 8, 7);
+
+    json_decref(obj);
+}
+
+static void create_and_free_object_with_oom() {
+    int i;
+    char key[4];
+    json_t *obj = json_object();
+
+    for (i = 0; i < 10; i++) {
+        snprintf(key, sizeof key, "%d", i);
+        json_object_set_new(obj, key, json_integer(i));
+    }
+
+    json_decref(obj);
+}
+
+static void *my_malloc(size_t size) {
+    malloc_called = 1;
+    return malloc(size);
+}
+
+static void my_free(void *ptr) {
+    free_called = 1;
+    free(ptr);
+}
+
+static void test_simple() {
+    json_malloc_t mfunc = NULL;
+    json_free_t ffunc = NULL;
+
+    json_set_alloc_funcs(my_malloc, my_free);
+    json_get_alloc_funcs(&mfunc, &ffunc);
+    create_and_free_complex_object();
+
+    if (malloc_called != 1 || free_called != 1 || mfunc != my_malloc || ffunc != my_free)
+        fail("Custom allocation failed");
+}
+
+static void *oom_malloc(size_t size) {
+    if (malloc_used + size > 800)
+        return NULL;
+
+    malloc_used += size;
+    return malloc(size);
+}
+
+static void oom_free(void *ptr) {
+    free_called++;
+    free(ptr);
+}
+
+static void test_oom() {
+    free_called = 0;
+    json_set_alloc_funcs(oom_malloc, oom_free);
+    create_and_free_object_with_oom();
+
+    if (free_called == 0)
+        fail("Allocation with OOM failed");
+}
+
+/*
+  Test the secure memory functions code given in the API reference
+  documentation, but by using plain memset instead of
+  guaranteed_memset().
+*/
+
+static void *secure_malloc(size_t size) {
+    /* Store the memory area size in the beginning of the block */
+    void *ptr = malloc(size + 8);
+    *((size_t *)ptr) = size;
+    return (char *)ptr + 8;
+}
+
+static void secure_free(void *ptr) {
+    size_t size;
+
+    ptr = (char *)ptr - 8;
+    size = *((size_t *)ptr);
+
+    /*guaranteed_*/ memset(ptr, 0, size + 8);
+    free(ptr);
+}
+
+static void test_secure_funcs(void) {
+    json_set_alloc_funcs(secure_malloc, secure_free);
+    create_and_free_complex_object();
+}
+
+static void test_bad_args(void) {
+    /* The result of this test is not crashing. */
+    json_get_alloc_funcs(NULL, NULL);
+}
+
+static void run_tests() {
+    test_simple();
+    test_secure_funcs();
+    test_oom();
+    test_bad_args();
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_number.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_number.c
new file mode 100644
index 000000000..2a22a67d3
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_number.c
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "util.h"
+#include <jansson.h>
+#include <math.h>
+
+#ifdef INFINITY
+// This test triggers "warning C4756: overflow in constant arithmetic"
+// in Visual Studio. This warning is triggered here by design, so disable it.
+// (This can only be done on function level so we keep these tests separate)
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4756)
+#endif
+static void test_inifity() {
+    json_t *real = json_real(INFINITY);
+    if (real != NULL)
+        fail("could construct a real from Inf");
+
+    real = json_real(1.0);
+    if (json_real_set(real, INFINITY) != -1)
+        fail("could set a real to Inf");
+
+    if (json_real_value(real) != 1.0)
+        fail("real value changed unexpectedly");
+
+    json_decref(real);
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+}
+#endif // INFINITY
+
+static void test_bad_args(void) {
+    json_t *txt = json_string("test");
+
+    if (json_integer_value(NULL) != 0)
+        fail("json_integer_value did not return 0 for non-integer");
+    if (json_integer_value(txt) != 0)
+        fail("json_integer_value did not return 0 for non-integer");
+
+    if (!json_integer_set(NULL, 0))
+        fail("json_integer_set did not return error for non-integer");
+    if (!json_integer_set(txt, 0))
+        fail("json_integer_set did not return error for non-integer");
+
+    if (json_real_value(NULL) != 0.0)
+        fail("json_real_value did not return 0.0 for non-real");
+    if (json_real_value(txt) != 0.0)
+        fail("json_real_value did not return 0.0 for non-real");
+
+    if (!json_real_set(NULL, 0.0))
+        fail("json_real_set did not return error for non-real");
+    if (!json_real_set(txt, 0.0))
+        fail("json_real_set did not return error for non-real");
+
+    if (json_number_value(NULL) != 0.0)
+        fail("json_number_value did not return 0.0 for non-numeric");
+    if (json_number_value(txt) != 0.0)
+        fail("json_number_value did not return 0.0 for non-numeric");
+
+    if (txt->refcount != 1)
+        fail("unexpected reference count for txt");
+
+    json_decref(txt);
+}
+
+static void run_tests() {
+    json_t *integer, *real;
+    json_int_t i;
+    double d;
+
+    integer = json_integer(5);
+    real = json_real(100.1);
+
+    if (!integer)
+        fail("unable to create integer");
+    if (!real)
+        fail("unable to create real");
+
+    i = json_integer_value(integer);
+    if (i != 5)
+        fail("wrong integer value");
+
+    d = json_real_value(real);
+    if (d != 100.1)
+        fail("wrong real value");
+
+    d = json_number_value(integer);
+    if (d != 5.0)
+        fail("wrong number value");
+    d = json_number_value(real);
+    if (d != 100.1)
+        fail("wrong number value");
+
+    json_decref(integer);
+    json_decref(real);
+
+#ifdef NAN
+    real = json_real(NAN);
+    if (real != NULL)
+        fail("could construct a real from NaN");
+
+    real = json_real(1.0);
+    if (json_real_set(real, NAN) != -1)
+        fail("could set a real to NaN");
+
+    if (json_real_value(real) != 1.0)
+        fail("real value changed unexpectedly");
+
+    json_decref(real);
+#endif
+
+#ifdef INFINITY
+    test_inifity();
+#endif
+    test_bad_args();
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_object.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_object.c
new file mode 100644
index 000000000..331edf229
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_object.c
@@ -0,0 +1,797 @@
+/*
+ * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "util.h"
+#include <jansson.h>
+#include <string.h>
+
+static void test_clear() {
+    json_t *object, *ten;
+
+    object = json_object();
+    ten = json_integer(10);
+
+    if (!object)
+        fail("unable to create object");
+    if (!ten)
+        fail("unable to create integer");
+
+    if (json_object_set(object, "a", ten) || json_object_set(object, "b", ten) ||
+        json_object_set(object, "c", ten) || json_object_set(object, "d", ten) ||
+        json_object_set(object, "e", ten))
+        fail("unable to set value");
+
+    if (json_object_size(object) != 5)
+        fail("invalid size");
+
+    json_object_clear(object);
+
+    if (json_object_size(object) != 0)
+        fail("invalid size after clear");
+
+    json_decref(ten);
+    json_decref(object);
+}
+
+static void test_update() {
+    json_t *object, *other, *nine, *ten;
+
+    object = json_object();
+    other = json_object();
+
+    nine = json_integer(9);
+    ten = json_integer(10);
+
+    if (!object || !other)
+        fail("unable to create object");
+    if (!nine || !ten)
+        fail("unable to create integer");
+
+    /* update an empty object with an empty object */
+
+    if (json_object_update(object, other))
+        fail("unable to update an empty object with an empty object");
+
+    if (json_object_size(object) != 0)
+        fail("invalid size after update");
+
+    if (json_object_size(other) != 0)
+        fail("invalid size for updater after update");
+
+    /* update an empty object with a nonempty object */
+
+    if (json_object_set(other, "a", ten) || json_object_set(other, "b", ten) ||
+        json_object_set(other, "c", ten) || json_object_set(other, "d", ten) ||
+        json_object_set(other, "e", ten))
+        fail("unable to set value");
+
+    if (json_object_update(object, other))
+        fail("unable to update an empty object");
+
+    if (json_object_size(object) != 5)
+        fail("invalid size after update");
+
+    if (json_object_get(object, "a") != ten || json_object_get(object, "b") != ten ||
+        json_object_get(object, "c") != ten || json_object_get(object, "d") != ten ||
+        json_object_get(object, "e") != ten)
+        fail("update works incorrectly");
+
+    /* perform the same update again */
+
+    if (json_object_update(object, other))
+        fail("unable to update a non-empty object");
+
+    if (json_object_size(object) != 5)
+        fail("invalid size after update");
+
+    if (json_object_get(object, "a") != ten || json_object_get(object, "b") != ten ||
+        json_object_get(object, "c") != ten || json_object_get(object, "d") != ten ||
+        json_object_get(object, "e") != ten)
+        fail("update works incorrectly");
+
+    /* update a nonempty object with a nonempty object with both old
+       and new keys */
+
+    if (json_object_clear(other))
+        fail("clear failed");
+
+    if (json_object_set(other, "a", nine) || json_object_set(other, "b", nine) ||
+        json_object_set(other, "f", nine) || json_object_set(other, "g", nine) ||
+        json_object_set(other, "h", nine))
+        fail("unable to set value");
+
+    if (json_object_update(object, other))
+        fail("unable to update a nonempty object");
+
+    if (json_object_size(object) != 8)
+        fail("invalid size after update");
+
+    if (json_object_get(object, "a") != nine || json_object_get(object, "b") != nine ||
+        json_object_get(object, "f") != nine || json_object_get(object, "g") != nine ||
+        json_object_get(object, "h") != nine)
+        fail("update works incorrectly");
+
+    /* update_new check */
+    if (json_object_clear(object))
+        fail("clear failed");
+
+    if (json_object_set(object, "a", ten) || json_object_set(object, "b", ten) ||
+        json_object_set(object, "c", ten) || json_object_set(object, "d", ten) ||
+        json_object_set(object, "e", ten))
+        fail("unable to set value");
+
+    if (json_object_update_new(
+            object, json_pack("{s:O, s:O, s:O}", "b", nine, "f", nine, "g", nine)))
+        fail("unable to update_new a nonempty object");
+
+    if (json_object_size(object) != 7)
+        fail("invalid size after update_new");
+
+    if (json_object_get(object, "a") != ten || json_object_get(object, "b") != nine ||
+        json_object_get(object, "c") != ten || json_object_get(object, "d") != ten ||
+        json_object_get(object, "e") != ten || json_object_get(object, "f") != nine ||
+        json_object_get(object, "g") != nine)
+        fail("update_new works incorrectly");
+
+    json_decref(nine);
+    json_decref(ten);
+    json_decref(other);
+    json_decref(object);
+}
+
+static void test_set_many_keys() {
+    json_t *object, *value;
+    const char *keys = "abcdefghijklmnopqrstuvwxyz";
+    char buf[2];
+    size_t i;
+
+    object = json_object();
+    if (!object)
+        fail("unable to create object");
+
+    value = json_string("a");
+    if (!value)
+        fail("unable to create string");
+
+    buf[1] = '\0';
+    for (i = 0; i < strlen(keys); i++) {
+        buf[0] = keys[i];
+        if (json_object_set(object, buf, value))
+            fail("unable to set object key");
+    }
+
+    json_decref(object);
+    json_decref(value);
+}
+
+static void test_conditional_updates() {
+    json_t *object, *other;
+
+    object = json_pack("{sisi}", "foo", 1, "bar", 2);
+    other = json_pack("{sisi}", "foo", 3, "baz", 4);
+
+    if (json_object_update_existing(object, other))
+        fail("json_object_update_existing failed");
+
+    if (json_object_size(object) != 2)
+        fail("json_object_update_existing added new items");
+
+    if (json_integer_value(json_object_get(object, "foo")) != 3)
+        fail("json_object_update_existing failed to update existing key");
+
+    if (json_integer_value(json_object_get(object, "bar")) != 2)
+        fail("json_object_update_existing updated wrong key");
+
+    json_decref(object);
+
+    /* json_object_update_existing_new check */
+    object = json_pack("{sisi}", "foo", 1, "bar", 2);
+
+    if (json_object_update_existing_new(object, json_pack("{sisi}", "foo", 3, "baz", 4)))
+        fail("json_object_update_existing_new failed");
+
+    if (json_object_size(object) != 2)
+        fail("json_object_update_existing_new added new items");
+
+    if (json_integer_value(json_object_get(object, "foo")) != 3)
+        fail("json_object_update_existing_new failed to update existing key");
+
+    if (json_integer_value(json_object_get(object, "bar")) != 2)
+        fail("json_object_update_existing_new updated wrong key");
+
+    json_decref(object);
+
+    object = json_pack("{sisi}", "foo", 1, "bar", 2);
+
+    if (json_object_update_missing(object, other))
+        fail("json_object_update_missing failed");
+
+    if (json_object_size(object) != 3)
+        fail("json_object_update_missing didn't add new items");
+
+    if (json_integer_value(json_object_get(object, "foo")) != 1)
+        fail("json_object_update_missing updated existing key");
+
+    if (json_integer_value(json_object_get(object, "bar")) != 2)
+        fail("json_object_update_missing updated wrong key");
+
+    if (json_integer_value(json_object_get(object, "baz")) != 4)
+        fail("json_object_update_missing didn't add new items");
+
+    json_decref(object);
+
+    /* json_object_update_missing_new check */
+    object = json_pack("{sisi}", "foo", 1, "bar", 2);
+
+    if (json_object_update_missing_new(object, json_pack("{sisi}", "foo", 3, "baz", 4)))
+        fail("json_object_update_missing_new failed");
+
+    if (json_object_size(object) != 3)
+        fail("json_object_update_missing_new didn't add new items");
+
+    if (json_integer_value(json_object_get(object, "foo")) != 1)
+        fail("json_object_update_missing_new updated existing key");
+
+    if (json_integer_value(json_object_get(object, "bar")) != 2)
+        fail("json_object_update_missing_new updated wrong key");
+
+    if (json_integer_value(json_object_get(object, "baz")) != 4)
+        fail("json_object_update_missing_new didn't add new items");
+
+    json_decref(object);
+    json_decref(other);
+}
+
+static void test_recursive_updates() {
+    json_t *invalid, *object, *other, *barBefore, *barAfter;
+
+    invalid = json_integer(42);
+
+    object = json_pack("{sis{si}}", "foo", 1, "bar", "baz", 2);
+    other = json_pack("{sisisi}", "foo", 3, "bar", 4, "baz", 5);
+
+    if (!json_object_update_recursive(invalid, other))
+        fail("json_object_update_recursive accepted non-object argument");
+
+    json_decref(invalid);
+
+    if (json_object_update_recursive(object, other))
+        fail("json_object_update_recursive failed");
+
+    if (json_object_size(object) != 3)
+        fail("invalid size after update");
+
+    if (json_integer_value(json_object_get(object, "foo")) != 3)
+        fail("json_object_update_recursive failed to update existing key");
+
+    if (json_integer_value(json_object_get(object, "bar")) != 4)
+        fail("json_object_update_recursive failed to overwrite object");
+
+    if (json_integer_value(json_object_get(object, "baz")) != 5)
+        fail("json_object_update_recursive didn't add new item");
+
+    json_decref(object);
+    json_decref(other);
+
+    object = json_pack("{sis{si}}", "foo", 1, "bar", "baz", 2);
+    other = json_pack("{s{si}}", "bar", "baz", 3);
+    barBefore = json_object_get(object, "bar");
+
+    if (!barBefore)
+        fail("can't get bar object before json_object_update_recursive");
+
+    if (json_object_update_recursive(object, other))
+        fail("json_object_update_recursive failed");
+
+    if (json_object_size(object) != 2)
+        fail("invalid size after update");
+
+    if (!json_object_get(object, "foo"))
+        fail("json_object_update_recursive removed existing key");
+
+    if (json_integer_value(json_object_get(json_object_get(object, "bar"), "baz")) != 3)
+        fail("json_object_update_recursive failed to update nested value");
+
+    barAfter = json_object_get(object, "bar");
+    if (!barAfter)
+        fail("can't get bar object after json_object_update_recursive");
+
+    if (barBefore != barAfter)
+        fail("bar object reference changed after json_object_update_recursive");
+
+    json_decref(object);
+    json_decref(other);
+
+    /* check circular reference */
+    object = json_pack("{s{s{s{si}}}}", "foo", "bar", "baz", "xxx", 2);
+    other = json_pack("{s{s{si}}}", "foo", "bar", "baz", 2);
+    json_object_set(json_object_get(json_object_get(other, "foo"), "bar"), "baz",
+                    json_object_get(other, "foo"));
+
+    if (!json_object_update_recursive(object, other))
+        fail("json_object_update_recursive update a circular reference!");
+
+    json_object_set_new(json_object_get(json_object_get(other, "foo"), "bar"), "baz",
+                        json_integer(1));
+
+    if (json_object_update_recursive(object, other))
+        fail("json_object_update_recursive failed!");
+
+    json_decref(object);
+    json_decref(other);
+}
+
+static void test_circular() {
+    json_t *object1, *object2;
+
+    object1 = json_object();
+    object2 = json_object();
+    if (!object1 || !object2)
+        fail("unable to create object");
+
+    /* the simple case is checked */
+    if (json_object_set(object1, "a", object1) == 0)
+        fail("able to set self");
+
+    /* create circular references */
+    if (json_object_set(object1, "a", object2) || json_object_set(object2, "a", object1))
+        fail("unable to set value");
+
+    /* circularity is detected when dumping */
+    if (json_dumps(object1, 0) != NULL)
+        fail("able to dump circulars");
+
+    /* decref twice to deal with the circular references */
+    json_decref(object1);
+    json_decref(object2);
+    json_decref(object1);
+}
+
+static void test_set_nocheck() {
+    json_t *object, *string;
+
+    object = json_object();
+    string = json_string("bar");
+
+    if (!object)
+        fail("unable to create object");
+    if (!string)
+        fail("unable to create string");
+
+    if (json_object_set_nocheck(object, "foo", string))
+        fail("json_object_set_nocheck failed");
+    if (json_object_get(object, "foo") != string)
+        fail("json_object_get after json_object_set_nocheck failed");
+
+    /* invalid UTF-8 in key */
+    if (json_object_set_nocheck(object, "a\xefz", string))
+        fail("json_object_set_nocheck failed for invalid UTF-8");
+    if (json_object_get(object, "a\xefz") != string)
+        fail("json_object_get after json_object_set_nocheck failed");
+
+    if (json_object_set_new_nocheck(object, "bax", json_integer(123)))
+        fail("json_object_set_new_nocheck failed");
+    if (json_integer_value(json_object_get(object, "bax")) != 123)
+        fail("json_object_get after json_object_set_new_nocheck failed");
+
+    /* invalid UTF-8 in key */
+    if (json_object_set_new_nocheck(object, "asdf\xfe", json_integer(321)))
+        fail("json_object_set_new_nocheck failed for invalid UTF-8");
+    if (json_integer_value(json_object_get(object, "asdf\xfe")) != 321)
+        fail("json_object_get after json_object_set_new_nocheck failed");
+
+    json_decref(string);
+    json_decref(object);
+}
+
+static void test_iterators() {
+    json_t *object, *foo, *bar, *baz;
+    void *iter;
+
+    if (json_object_iter(NULL))
+        fail("able to iterate over NULL");
+
+    if (json_object_iter_next(NULL, NULL))
+        fail("able to increment an iterator on a NULL object");
+
+    object = json_object();
+    foo = json_string("foo");
+    bar = json_string("bar");
+    baz = json_string("baz");
+    if (!object || !foo || !bar || !baz)
+        fail("unable to create values");
+
+    if (json_object_iter_next(object, NULL))
+        fail("able to increment a NULL iterator");
+
+    if (json_object_set(object, "a", foo) || json_object_set(object, "b", bar) ||
+        json_object_set(object, "c", baz))
+        fail("unable to populate object");
+
+    iter = json_object_iter(object);
+    if (!iter)
+        fail("unable to get iterator");
+    if (strcmp(json_object_iter_key(iter), "a") != 0)
+        fail("iterating doesn't yield keys in order");
+    if (json_object_iter_value(iter) != foo)
+        fail("iterating doesn't yield values in order");
+
+    iter = json_object_iter_next(object, iter);
+    if (!iter)
+        fail("unable to increment iterator");
+    if (strcmp(json_object_iter_key(iter), "b") != 0)
+        fail("iterating doesn't yield keys in order");
+    if (json_object_iter_value(iter) != bar)
+        fail("iterating doesn't yield values in order");
+
+    iter = json_object_iter_next(object, iter);
+    if (!iter)
+        fail("unable to increment iterator");
+    if (strcmp(json_object_iter_key(iter), "c") != 0)
+        fail("iterating doesn't yield keys in order");
+    if (json_object_iter_value(iter) != baz)
+        fail("iterating doesn't yield values in order");
+
+    if (json_object_iter_next(object, iter) != NULL)
+        fail("able to iterate over the end");
+
+    if (json_object_iter_at(object, "foo"))
+        fail("json_object_iter_at() succeeds for non-existent key");
+
+    iter = json_object_iter_at(object, "b");
+    if (!iter)
+        fail("json_object_iter_at() fails for an existing key");
+
+    if (strcmp(json_object_iter_key(iter), "b"))
+        fail("iterating failed: wrong key");
+    if (json_object_iter_value(iter) != bar)
+        fail("iterating failed: wrong value");
+
+    if (json_object_iter_set(object, iter, baz))
+        fail("unable to set value at iterator");
+
+    if (strcmp(json_object_iter_key(iter), "b"))
+        fail("json_object_iter_key() fails after json_object_iter_set()");
+    if (json_object_iter_value(iter) != baz)
+        fail("json_object_iter_value() fails after json_object_iter_set()");
+    if (json_object_get(object, "b") != baz)
+        fail("json_object_get() fails after json_object_iter_set()");
+
+    json_decref(object);
+    json_decref(foo);
+    json_decref(bar);
+    json_decref(baz);
+}
+
+static void test_misc() {
+    json_t *object, *string, *other_string, *value;
+
+    object = json_object();
+    string = json_string("test");
+    other_string = json_string("other");
+
+    if (!object)
+        fail("unable to create object");
+    if (!string || !other_string)
+        fail("unable to create string");
+
+    if (json_object_get(object, "a"))
+        fail("value for nonexisting key");
+
+    if (json_object_set(object, "a", string))
+        fail("unable to set value");
+
+    if (!json_object_set(object, NULL, string))
+        fail("able to set NULL key");
+
+    if (json_object_del(object, "a"))
+        fail("unable to del the only key");
+
+    if (json_object_set(object, "a", string))
+        fail("unable to set value");
+
+    if (!json_object_set(object, "a", NULL))
+        fail("able to set NULL value");
+
+    /* invalid UTF-8 in key */
+    if (!json_object_set(object, "a\xefz", string))
+        fail("able to set invalid unicode key");
+
+    value = json_object_get(object, "a");
+    if (!value)
+        fail("no value for existing key");
+    if (value != string)
+        fail("got different value than what was added");
+
+    /* "a", "lp" and "px" collide in a five-bucket hashtable */
+    if (json_object_set(object, "b", string) || json_object_set(object, "lp", string) ||
+        json_object_set(object, "px", string))
+        fail("unable to set value");
+
+    value = json_object_get(object, "a");
+    if (!value)
+        fail("no value for existing key");
+    if (value != string)
+        fail("got different value than what was added");
+
+    if (json_object_set(object, "a", other_string))
+        fail("unable to replace an existing key");
+
+    value = json_object_get(object, "a");
+    if (!value)
+        fail("no value for existing key");
+    if (value != other_string)
+        fail("got different value than what was set");
+
+    if (!json_object_del(object, "nonexisting"))
+        fail("able to delete a nonexisting key");
+
+    if (json_object_del(object, "px"))
+        fail("unable to delete an existing key");
+
+    if (json_object_del(object, "a"))
+        fail("unable to delete an existing key");
+
+    if (json_object_del(object, "lp"))
+        fail("unable to delete an existing key");
+
+    /* add many keys to initiate rehashing */
+
+    if (json_object_set(object, "a", string))
+        fail("unable to set value");
+
+    if (json_object_set(object, "lp", string))
+        fail("unable to set value");
+
+    if (json_object_set(object, "px", string))
+        fail("unable to set value");
+
+    if (json_object_set(object, "c", string))
+        fail("unable to set value");
+
+    if (json_object_set(object, "d", string))
+        fail("unable to set value");
+
+    if (json_object_set(object, "e", string))
+        fail("unable to set value");
+
+    if (json_object_set_new(object, "foo", json_integer(123)))
+        fail("unable to set new value");
+
+    value = json_object_get(object, "foo");
+    if (!json_is_integer(value) || json_integer_value(value) != 123)
+        fail("json_object_set_new works incorrectly");
+
+    if (!json_object_set_new(object, NULL, json_integer(432)))
+        fail("able to set_new NULL key");
+
+    if (!json_object_set_new(object, "foo", NULL))
+        fail("able to set_new NULL value");
+
+    json_decref(string);
+    json_decref(other_string);
+    json_decref(object);
+}
+
+static void test_preserve_order() {
+    json_t *object;
+    char *result;
+
+    const char *expected = "{\"foobar\": 1, \"bazquux\": 6, \"lorem ipsum\": "
+                           "3, \"sit amet\": 5, \"helicopter\": 7}";
+
+    object = json_object();
+
+    json_object_set_new(object, "foobar", json_integer(1));
+    json_object_set_new(object, "bazquux", json_integer(2));
+    json_object_set_new(object, "lorem ipsum", json_integer(3));
+    json_object_set_new(object, "dolor", json_integer(4));
+    json_object_set_new(object, "sit amet", json_integer(5));
+
+    /* changing a value should preserve the order */
+    json_object_set_new(object, "bazquux", json_integer(6));
+
+    /* deletion shouldn't change the order of others */
+    json_object_del(object, "dolor");
+
+    /* add a new item just to make sure */
+    json_object_set_new(object, "helicopter", json_integer(7));
+
+    result = json_dumps(object, JSON_PRESERVE_ORDER);
+
+    if (strcmp(expected, result) != 0) {
+        fprintf(stderr, "%s != %s", expected, result);
+        fail("JSON_PRESERVE_ORDER doesn't work");
+    }
+
+    free(result);
+    json_decref(object);
+}
+
+static void test_object_foreach() {
+    const char *key;
+    json_t *object1, *object2, *value;
+
+    object1 = json_pack("{sisisi}", "foo", 1, "bar", 2, "baz", 3);
+    object2 = json_object();
+
+    json_object_foreach(object1, key, value) json_object_set(object2, key, value);
+
+    if (!json_equal(object1, object2))
+        fail("json_object_foreach failed to iterate all key-value pairs");
+
+    json_decref(object1);
+    json_decref(object2);
+}
+
+static void test_object_foreach_safe() {
+    const char *key;
+    void *tmp;
+    json_t *object, *value;
+
+    object = json_pack("{sisisi}", "foo", 1, "bar", 2, "baz", 3);
+
+    json_object_foreach_safe(object, tmp, key, value) { json_object_del(object, key); }
+
+    if (json_object_size(object) != 0)
+        fail("json_object_foreach_safe failed to iterate all key-value pairs");
+
+    json_decref(object);
+}
+
+static void test_bad_args(void) {
+    json_t *obj = json_object();
+    json_t *num = json_integer(1);
+    void *iter;
+
+    if (!obj || !num)
+        fail("failed to allocate test objects");
+
+    if (json_object_set(obj, "testkey", json_null()))
+        fail("failed to set testkey on object");
+
+    iter = json_object_iter(obj);
+    if (!iter)
+        fail("failed to retrieve test iterator");
+
+    if (json_object_size(NULL) != 0)
+        fail("json_object_size with non-object argument returned non-zero");
+    if (json_object_size(num) != 0)
+        fail("json_object_size with non-object argument returned non-zero");
+
+    if (json_object_get(NULL, "test") != NULL)
+        fail("json_object_get with non-object argument returned non-NULL");
+    if (json_object_get(num, "test") != NULL)
+        fail("json_object_get with non-object argument returned non-NULL");
+    if (json_object_get(obj, NULL) != NULL)
+        fail("json_object_get with NULL key returned non-NULL");
+
+    if (!json_object_set_new_nocheck(NULL, "test", json_null()))
+        fail("json_object_set_new_nocheck with non-object argument did not "
+             "return error");
+    if (!json_object_set_new_nocheck(num, "test", json_null()))
+        fail("json_object_set_new_nocheck with non-object argument did not "
+             "return error");
+    if (!json_object_set_new_nocheck(obj, "test", json_incref(obj)))
+        fail("json_object_set_new_nocheck with object == value did not return "
+             "error");
+    if (!json_object_set_new_nocheck(obj, NULL, json_object()))
+        fail("json_object_set_new_nocheck with NULL key did not return error");
+
+    if (!json_object_del(NULL, "test"))
+        fail("json_object_del with non-object argument did not return error");
+    if (!json_object_del(num, "test"))
+        fail("json_object_del with non-object argument did not return error");
+    if (!json_object_del(obj, NULL))
+        fail("json_object_del with NULL key did not return error");
+
+    if (!json_object_clear(NULL))
+        fail("json_object_clear with non-object argument did not return error");
+    if (!json_object_clear(num))
+        fail("json_object_clear with non-object argument did not return error");
+
+    if (!json_object_update(NULL, obj))
+        fail("json_object_update with non-object first argument did not return "
+             "error");
+    if (!json_object_update(num, obj))
+        fail("json_object_update with non-object first argument did not return "
+             "error");
+    if (!json_object_update(obj, NULL))
+        fail("json_object_update with non-object second argument did not "
+             "return error");
+    if (!json_object_update(obj, num))
+        fail("json_object_update with non-object second argument did not "
+             "return error");
+
+    if (!json_object_update_existing(NULL, obj))
+        fail("json_object_update_existing with non-object first argument did "
+             "not return error");
+    if (!json_object_update_existing(num, obj))
+        fail("json_object_update_existing with non-object first argument did "
+             "not return error");
+    if (!json_object_update_existing(obj, NULL))
+        fail("json_object_update_existing with non-object second argument did "
+             "not return error");
+    if (!json_object_update_existing(obj, num))
+        fail("json_object_update_existing with non-object second argument did "
+             "not return error");
+
+    if (!json_object_update_missing(NULL, obj))
+        fail("json_object_update_missing with non-object first argument did "
+             "not return error");
+    if (!json_object_update_missing(num, obj))
+        fail("json_object_update_missing with non-object first argument did "
+             "not return error");
+    if (!json_object_update_missing(obj, NULL))
+        fail("json_object_update_missing with non-object second argument did "
+             "not return error");
+    if (!json_object_update_missing(obj, num))
+        fail("json_object_update_missing with non-object second argument did "
+             "not return error");
+
+    if (json_object_iter(NULL) != NULL)
+        fail("json_object_iter with non-object argument returned non-NULL");
+    if (json_object_iter(num) != NULL)
+        fail("json_object_iter with non-object argument returned non-NULL");
+
+    if (json_object_iter_at(NULL, "test") != NULL)
+        fail("json_object_iter_at with non-object argument returned non-NULL");
+    if (json_object_iter_at(num, "test") != NULL)
+        fail("json_object_iter_at with non-object argument returned non-NULL");
+    if (json_object_iter_at(obj, NULL) != NULL)
+        fail("json_object_iter_at with NULL iter returned non-NULL");
+
+    if (json_object_iter_next(obj, NULL) != NULL)
+        fail("json_object_iter_next with NULL iter returned non-NULL");
+    if (json_object_iter_next(num, iter) != NULL)
+        fail("json_object_iter_next with non-object argument returned non-NULL");
+
+    if (json_object_iter_key(NULL) != NULL)
+        fail("json_object_iter_key with NULL iter returned non-NULL");
+
+    if (json_object_key_to_iter(NULL) != NULL)
+        fail("json_object_key_to_iter with NULL iter returned non-NULL");
+
+    if (json_object_iter_value(NULL) != NULL)
+        fail("json_object_iter_value with NULL iter returned non-NULL");
+
+    if (!json_object_iter_set_new(NULL, iter, json_incref(num)))
+        fail("json_object_iter_set_new with non-object argument did not return "
+             "error");
+    if (!json_object_iter_set_new(num, iter, json_incref(num)))
+        fail("json_object_iter_set_new with non-object argument did not return "
+             "error");
+    if (!json_object_iter_set_new(obj, NULL, json_incref(num)))
+        fail("json_object_iter_set_new with NULL iter did not return error");
+    if (!json_object_iter_set_new(obj, iter, NULL))
+        fail("json_object_iter_set_new with NULL value did not return error");
+
+    if (obj->refcount != 1)
+        fail("unexpected reference count for obj");
+
+    if (num->refcount != 1)
+        fail("unexpected reference count for num");
+
+    json_decref(obj);
+    json_decref(num);
+}
+
+static void run_tests() {
+    test_misc();
+    test_clear();
+    test_update();
+    test_set_many_keys();
+    test_conditional_updates();
+    test_recursive_updates();
+    test_circular();
+    test_set_nocheck();
+    test_iterators();
+    test_preserve_order();
+    test_object_foreach();
+    test_object_foreach_safe();
+    test_bad_args();
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_pack.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_pack.c
new file mode 100644
index 000000000..865f60b68
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_pack.c
@@ -0,0 +1,547 @@
+/*
+ * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+ * Copyright (c) 2010-2012 Graeme Smecher <graeme.smecher@mail.mcgill.ca>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <jansson_private_config.h>
+#endif
+
+#include <jansson_config.h>
+
+#include "util.h"
+#include <jansson.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifdef INFINITY
+// This test triggers "warning C4756: overflow in constant arithmetic"
+// in Visual Studio. This warning is triggered here by design, so disable it.
+// (This can only be done on function level so we keep these tests separate)
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4756)
+#endif
+static void test_inifity() {
+    json_error_t error;
+
+    if (json_pack_ex(&error, 0, "f", INFINITY))
+        fail("json_pack infinity incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1,
+                1, 1);
+
+    if (json_pack_ex(&error, 0, "[f]", INFINITY))
+        fail("json_pack infinity array element incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1,
+                2, 2);
+
+    if (json_pack_ex(&error, 0, "{s:f}", "key", INFINITY))
+        fail("json_pack infinity object value incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1,
+                4, 4);
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+}
+#endif // INFINITY
+
+static void run_tests() {
+    json_t *value;
+    int i;
+    char buffer[4] = {'t', 'e', 's', 't'};
+    json_error_t error;
+
+    /*
+     * Simple, valid json_pack cases
+     */
+    /* true */
+    value = json_pack("b", 1);
+    if (!json_is_true(value))
+        fail("json_pack boolean failed");
+    if (value->refcount != (size_t)-1)
+        fail("json_pack boolean refcount failed");
+    json_decref(value);
+
+    /* false */
+    value = json_pack("b", 0);
+    if (!json_is_false(value))
+        fail("json_pack boolean failed");
+    if (value->refcount != (size_t)-1)
+        fail("json_pack boolean refcount failed");
+    json_decref(value);
+
+    /* null */
+    value = json_pack("n");
+    if (!json_is_null(value))
+        fail("json_pack null failed");
+    if (value->refcount != (size_t)-1)
+        fail("json_pack null refcount failed");
+    json_decref(value);
+
+    /* integer */
+    value = json_pack("i", 1);
+    if (!json_is_integer(value) || json_integer_value(value) != 1)
+        fail("json_pack integer failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack integer refcount failed");
+    json_decref(value);
+
+    /* integer from json_int_t */
+    value = json_pack("I", (json_int_t)555555);
+    if (!json_is_integer(value) || json_integer_value(value) != 555555)
+        fail("json_pack json_int_t failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack integer refcount failed");
+    json_decref(value);
+
+    /* real */
+    value = json_pack("f", 1.0);
+    if (!json_is_real(value) || json_real_value(value) != 1.0)
+        fail("json_pack real failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack real refcount failed");
+    json_decref(value);
+
+    /* string */
+    value = json_pack("s", "test");
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
+        fail("json_pack string failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack string refcount failed");
+    json_decref(value);
+
+    /* nullable string (defined case) */
+    value = json_pack("s?", "test");
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
+        fail("json_pack nullable string (defined case) failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack nullable string (defined case) refcount failed");
+    json_decref(value);
+
+    /* nullable string (NULL case) */
+    value = json_pack("s?", NULL);
+    if (!json_is_null(value))
+        fail("json_pack nullable string (NULL case) failed");
+    if (value->refcount != (size_t)-1)
+        fail("json_pack nullable string (NULL case) refcount failed");
+    json_decref(value);
+
+    /* nullable string concatenation */
+    if (json_pack_ex(&error, 0, "s?+", "test", "ing"))
+        fail("json_pack failed to catch invalid format 's?+'");
+    check_error(json_error_invalid_format, "Cannot use '+' on optional strings",
+                "<format>", 1, 2, 2);
+
+    /* nullable string with integer length */
+    if (json_pack_ex(&error, 0, "s?#", "test", 4))
+        fail("json_pack failed to catch invalid format 's?#'");
+    check_error(json_error_invalid_format, "Cannot use '#' on optional strings",
+                "<format>", 1, 2, 2);
+
+    /* string and length (int) */
+    value = json_pack("s#", "test asdf", 4);
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
+        fail("json_pack string and length failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack string and length refcount failed");
+    json_decref(value);
+
+    /* string and length (size_t) */
+    value = json_pack("s%", "test asdf", (size_t)4);
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
+        fail("json_pack string and length failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack string and length refcount failed");
+    json_decref(value);
+
+    /* string and length (int), non-NUL terminated string */
+    value = json_pack("s#", buffer, 4);
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
+        fail("json_pack string and length (int) failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack string and length (int) refcount failed");
+    json_decref(value);
+
+    /* string and length (size_t), non-NUL terminated string */
+    value = json_pack("s%", buffer, (size_t)4);
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
+        fail("json_pack string and length (size_t) failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack string and length (size_t) refcount failed");
+    json_decref(value);
+
+    /* string concatenation */
+    if (json_pack("s+", "test", NULL))
+        fail("json_pack string concatenation succeeded with NULL string");
+
+    value = json_pack("s++", "te", "st", "ing");
+    if (!json_is_string(value) || strcmp("testing", json_string_value(value)))
+        fail("json_pack string concatenation failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack string concatenation refcount failed");
+    json_decref(value);
+
+    /* string concatenation and length (int) */
+    value = json_pack("s#+#+", "test", 1, "test", 2, "test");
+    if (!json_is_string(value) || strcmp("ttetest", json_string_value(value)))
+        fail("json_pack string concatenation and length (int) failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack string concatenation and length (int) refcount failed");
+    json_decref(value);
+
+    /* string concatenation and length (size_t) */
+    value = json_pack("s%+%+", "test", (size_t)1, "test", (size_t)2, "test");
+    if (!json_is_string(value) || strcmp("ttetest", json_string_value(value)))
+        fail("json_pack string concatenation and length (size_t) failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack string concatenation and length (size_t) refcount "
+             "failed");
+    json_decref(value);
+
+    /* empty object */
+    value = json_pack("{}", 1.0);
+    if (!json_is_object(value) || json_object_size(value) != 0)
+        fail("json_pack empty object failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack empty object refcount failed");
+    json_decref(value);
+
+    /* empty list */
+    value = json_pack("[]", 1.0);
+    if (!json_is_array(value) || json_array_size(value) != 0)
+        fail("json_pack empty list failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack empty list failed");
+    json_decref(value);
+
+    /* non-incref'd object */
+    value = json_pack("o", json_integer(1));
+    if (!json_is_integer(value) || json_integer_value(value) != 1)
+        fail("json_pack object failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack integer refcount failed");
+    json_decref(value);
+
+    /* non-incref'd nullable object (defined case) */
+    value = json_pack("o?", json_integer(1));
+    if (!json_is_integer(value) || json_integer_value(value) != 1)
+        fail("json_pack nullable object (defined case) failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack nullable object (defined case) refcount failed");
+    json_decref(value);
+
+    /* non-incref'd nullable object (NULL case) */
+    value = json_pack("o?", NULL);
+    if (!json_is_null(value))
+        fail("json_pack nullable object (NULL case) failed");
+    if (value->refcount != (size_t)-1)
+        fail("json_pack nullable object (NULL case) refcount failed");
+    json_decref(value);
+
+    /* incref'd object */
+    value = json_pack("O", json_integer(1));
+    if (!json_is_integer(value) || json_integer_value(value) != 1)
+        fail("json_pack object failed");
+    if (value->refcount != (size_t)2)
+        fail("json_pack integer refcount failed");
+    json_decref(value);
+    json_decref(value);
+
+    /* incref'd nullable object (defined case) */
+    value = json_pack("O?", json_integer(1));
+    if (!json_is_integer(value) || json_integer_value(value) != 1)
+        fail("json_pack incref'd nullable object (defined case) failed");
+    if (value->refcount != (size_t)2)
+        fail("json_pack incref'd nullable object (defined case) refcount "
+             "failed");
+    json_decref(value);
+    json_decref(value);
+
+    /* incref'd nullable object (NULL case) */
+    value = json_pack("O?", NULL);
+    if (!json_is_null(value))
+        fail("json_pack incref'd nullable object (NULL case) failed");
+    if (value->refcount != (size_t)-1)
+        fail("json_pack incref'd nullable object (NULL case) refcount failed");
+
+    /* simple object */
+    value = json_pack("{s:[]}", "foo");
+    if (!json_is_object(value) || json_object_size(value) != 1)
+        fail("json_pack array failed");
+    if (!json_is_array(json_object_get(value, "foo")))
+        fail("json_pack array failed");
+    if (json_object_get(value, "foo")->refcount != (size_t)1)
+        fail("json_pack object refcount failed");
+    json_decref(value);
+
+    /* object with complex key */
+    value = json_pack("{s+#+: []}", "foo", "barbar", 3, "baz");
+    if (!json_is_object(value) || json_object_size(value) != 1)
+        fail("json_pack array failed");
+    if (!json_is_array(json_object_get(value, "foobarbaz")))
+        fail("json_pack array failed");
+    if (json_object_get(value, "foobarbaz")->refcount != (size_t)1)
+        fail("json_pack object refcount failed");
+    json_decref(value);
+
+    /* object with optional members */
+    value = json_pack("{s:s,s:o,s:O}", "a", NULL, "b", NULL, "c", NULL);
+    if (value)
+        fail("json_pack object optional incorrectly succeeded");
+
+    value = json_pack("{s:**}", "a", NULL);
+    if (value)
+        fail("json_pack object optional invalid incorrectly succeeded");
+
+    if (json_pack_ex(&error, 0, "{s:i*}", "a", 1))
+        fail("json_pack object optional invalid incorrectly succeeded");
+    check_error(json_error_invalid_format, "Expected format 's', got '*'", "<format>", 1,
+                5, 5);
+
+    value = json_pack("{s:s*,s:o*,s:O*}", "a", NULL, "b", NULL, "c", NULL);
+    if (!json_is_object(value) || json_object_size(value) != 0)
+        fail("json_pack object optional failed");
+    json_decref(value);
+
+    value = json_pack("{s:s*}", "key", "\xff\xff");
+    if (value)
+        fail("json_pack object optional with invalid UTF-8 incorrectly "
+             "succeeded");
+
+    if (json_pack_ex(&error, 0, "{s: s*#}", "key", "test", 1))
+        fail("json_pack failed to catch invalid format 's*#'");
+    check_error(json_error_invalid_format, "Cannot use '#' on optional strings",
+                "<format>", 1, 6, 6);
+
+    if (json_pack_ex(&error, 0, "{s: s*+}", "key", "test", "ing"))
+        fail("json_pack failed to catch invalid format 's*+'");
+    check_error(json_error_invalid_format, "Cannot use '+' on optional strings",
+                "<format>", 1, 6, 6);
+
+    /* simple array */
+    value = json_pack("[i,i,i]", 0, 1, 2);
+    if (!json_is_array(value) || json_array_size(value) != 3)
+        fail("json_pack object failed");
+    for (i = 0; i < 3; i++) {
+        if (!json_is_integer(json_array_get(value, i)) ||
+            json_integer_value(json_array_get(value, i)) != i)
+
+            fail("json_pack integer array failed");
+    }
+    json_decref(value);
+
+    /* simple array with optional members */
+    value = json_pack("[s,o,O]", NULL, NULL, NULL);
+    if (value)
+        fail("json_pack array optional incorrectly succeeded");
+
+    if (json_pack_ex(&error, 0, "[i*]", 1))
+        fail("json_pack array optional invalid incorrectly succeeded");
+    check_error(json_error_invalid_format, "Unexpected format character '*'", "<format>",
+                1, 3, 3);
+
+    value = json_pack("[**]", NULL);
+    if (value)
+        fail("json_pack array optional invalid incorrectly succeeded");
+    value = json_pack("[s*,o*,O*]", NULL, NULL, NULL);
+    if (!json_is_array(value) || json_array_size(value) != 0)
+        fail("json_pack array optional failed");
+    json_decref(value);
+
+#ifdef NAN
+    /* Invalid float values */
+    if (json_pack_ex(&error, 0, "f", NAN))
+        fail("json_pack NAN incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1,
+                1, 1);
+
+    if (json_pack_ex(&error, 0, "[f]", NAN))
+        fail("json_pack NAN array element incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1,
+                2, 2);
+
+    if (json_pack_ex(&error, 0, "{s:f}", "key", NAN))
+        fail("json_pack NAN object value incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1,
+                4, 4);
+#endif
+
+#ifdef INFINITY
+    test_inifity();
+#endif
+
+    /* Whitespace; regular string */
+    value = json_pack(" s\t ", "test");
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
+        fail("json_pack string (with whitespace) failed");
+    json_decref(value);
+
+    /* Whitespace; empty array */
+    value = json_pack("[ ]");
+    if (!json_is_array(value) || json_array_size(value) != 0)
+        fail("json_pack empty array (with whitespace) failed");
+    json_decref(value);
+
+    /* Whitespace; array */
+    value = json_pack("[ i , i,  i ] ", 1, 2, 3);
+    if (!json_is_array(value) || json_array_size(value) != 3)
+        fail("json_pack array (with whitespace) failed");
+    json_decref(value);
+
+    /*
+     * Invalid cases
+     */
+
+    /* newline in format string */
+    if (json_pack_ex(&error, 0, "{\n\n1"))
+        fail("json_pack failed to catch invalid format '1'");
+    check_error(json_error_invalid_format, "Expected format 's', got '1'", "<format>", 3,
+                1, 4);
+
+    /* mismatched open/close array/object */
+    if (json_pack_ex(&error, 0, "[}"))
+        fail("json_pack failed to catch mismatched '}'");
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>",
+                1, 2, 2);
+
+    if (json_pack_ex(&error, 0, "{]"))
+        fail("json_pack failed to catch mismatched ']'");
+    check_error(json_error_invalid_format, "Expected format 's', got ']'", "<format>", 1,
+                2, 2);
+
+    /* missing close array */
+    if (json_pack_ex(&error, 0, "["))
+        fail("json_pack failed to catch missing ']'");
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>",
+                1, 2, 2);
+
+    /* missing close object */
+    if (json_pack_ex(&error, 0, "{"))
+        fail("json_pack failed to catch missing '}'");
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>",
+                1, 2, 2);
+
+    /* garbage after format string */
+    if (json_pack_ex(&error, 0, "[i]a", 42))
+        fail("json_pack failed to catch garbage after format string");
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1,
+                4, 4);
+
+    if (json_pack_ex(&error, 0, "ia", 42))
+        fail("json_pack failed to catch garbage after format string");
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1,
+                2, 2);
+
+    /* NULL string */
+    if (json_pack_ex(&error, 0, "s", NULL))
+        fail("json_pack failed to catch null argument string");
+    check_error(json_error_null_value, "NULL string", "<args>", 1, 1, 1);
+
+    /* + on its own */
+    if (json_pack_ex(&error, 0, "+", NULL))
+        fail("json_pack failed to a lone +");
+    check_error(json_error_invalid_format, "Unexpected format character '+'", "<format>",
+                1, 1, 1);
+
+    /* Empty format */
+    if (json_pack_ex(&error, 0, ""))
+        fail("json_pack failed to catch empty format string");
+    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>",
+                -1, -1, 0);
+
+    /* NULL format */
+    if (json_pack_ex(&error, 0, NULL))
+        fail("json_pack failed to catch NULL format string");
+    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>",
+                -1, -1, 0);
+
+    /* NULL key */
+    if (json_pack_ex(&error, 0, "{s:i}", NULL, 1))
+        fail("json_pack failed to catch NULL key");
+    check_error(json_error_null_value, "NULL object key", "<args>", 1, 2, 2);
+
+    /* NULL value followed by object still steals the object's ref */
+    value = json_incref(json_object());
+    if (json_pack_ex(&error, 0, "{s:s,s:o}", "badnull", NULL, "dontleak", value))
+        fail("json_pack failed to catch NULL value");
+    check_error(json_error_null_value, "NULL string", "<args>", 1, 4, 4);
+    if (value->refcount != (size_t)1)
+        fail("json_pack failed to steal reference after error.");
+    json_decref(value);
+
+    /* More complicated checks for row/columns */
+    if (json_pack_ex(&error, 0, "{ {}: s }", "foo"))
+        fail("json_pack failed to catch object as key");
+    check_error(json_error_invalid_format, "Expected format 's', got '{'", "<format>", 1,
+                3, 3);
+
+    /* Complex object */
+    if (json_pack_ex(&error, 0, "{ s: {},  s:[ii{} }", "foo", "bar", 12, 13))
+        fail("json_pack failed to catch missing ]");
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>",
+                1, 19, 19);
+
+    /* Complex array */
+    if (json_pack_ex(&error, 0, "[[[[[   [[[[[  [[[[ }]]]] ]]]] ]]]]]"))
+        fail("json_pack failed to catch extra }");
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>",
+                1, 21, 21);
+
+    /* Invalid UTF-8 in object key */
+    if (json_pack_ex(&error, 0, "{s:i}", "\xff\xff", 42))
+        fail("json_pack failed to catch invalid UTF-8 in an object key");
+    check_error(json_error_invalid_utf8, "Invalid UTF-8 object key", "<args>", 1, 2, 2);
+
+    /* Invalid UTF-8 in a string */
+    if (json_pack_ex(&error, 0, "{s:s}", "foo", "\xff\xff"))
+        fail("json_pack failed to catch invalid UTF-8 in a string");
+    check_error(json_error_invalid_utf8, "Invalid UTF-8 string", "<args>", 1, 4, 4);
+
+    /* Invalid UTF-8 in an optional '?' string */
+    if (json_pack_ex(&error, 0, "{s:s?}", "foo", "\xff\xff"))
+        fail("json_pack failed to catch invalid UTF-8 in an optional '?' "
+             "string");
+    check_error(json_error_invalid_utf8, "Invalid UTF-8 string", "<args>", 1, 5, 5);
+
+    /* Invalid UTF-8 in an optional '*' string */
+    if (json_pack_ex(&error, 0, "{s:s*}", "foo", "\xff\xff"))
+        fail("json_pack failed to catch invalid UTF-8 in an optional '*' "
+             "string");
+    check_error(json_error_invalid_utf8, "Invalid UTF-8 string", "<args>", 1, 5, 5);
+
+    /* Invalid UTF-8 in a concatenated key */
+    if (json_pack_ex(&error, 0, "{s+:i}", "\xff\xff", "concat", 42))
+        fail("json_pack failed to catch invalid UTF-8 in an object key");
+    check_error(json_error_invalid_utf8, "Invalid UTF-8 object key", "<args>", 1, 3, 3);
+
+    if (json_pack_ex(&error, 0, "{s:o}", "foo", NULL))
+        fail("json_pack failed to catch nullable object");
+    check_error(json_error_null_value, "NULL object", "<args>", 1, 4, 4);
+
+    if (json_pack_ex(&error, 0, "{s:O}", "foo", NULL))
+        fail("json_pack failed to catch nullable incref object");
+    check_error(json_error_null_value, "NULL object", "<args>", 1, 4, 4);
+
+    if (json_pack_ex(&error, 0, "{s+:o}", "foo", "bar", NULL))
+        fail("json_pack failed to catch non-nullable object value");
+    check_error(json_error_null_value, "NULL object", "<args>", 1, 5, 5);
+
+    if (json_pack_ex(&error, 0, "[1s", "Hi"))
+        fail("json_pack failed to catch invalid format");
+    check_error(json_error_invalid_format, "Unexpected format character '1'", "<format>",
+                1, 2, 2);
+
+    if (json_pack_ex(&error, 0, "[1s+", "Hi", "ya"))
+        fail("json_pack failed to catch invalid format");
+    check_error(json_error_invalid_format, "Unexpected format character '1'", "<format>",
+                1, 2, 2);
+
+    if (json_pack_ex(&error, 0, "[so]", NULL, json_object()))
+        fail("json_pack failed to catch NULL value");
+    check_error(json_error_null_value, "NULL string", "<args>", 1, 2, 2);
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_simple.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_simple.c
new file mode 100644
index 000000000..7a3f6b7bf
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_simple.c
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "util.h"
+#include <jansson.h>
+#include <string.h>
+
+static void test_bad_args(void) {
+    json_t *num = json_integer(1);
+    json_t *txt = json_string("test");
+
+    if (!num || !txt)
+        fail("failed to allocate test objects");
+
+    if (json_string_nocheck(NULL) != NULL)
+        fail("json_string_nocheck with NULL argument did not return NULL");
+    if (json_stringn_nocheck(NULL, 0) != NULL)
+        fail("json_stringn_nocheck with NULL argument did not return NULL");
+    if (json_string(NULL) != NULL)
+        fail("json_string with NULL argument did not return NULL");
+    if (json_stringn(NULL, 0) != NULL)
+        fail("json_stringn with NULL argument did not return NULL");
+
+    if (json_string_length(NULL) != 0)
+        fail("json_string_length with non-string argument did not return 0");
+    if (json_string_length(num) != 0)
+        fail("json_string_length with non-string argument did not return 0");
+
+    if (json_string_value(NULL) != NULL)
+        fail("json_string_value with non-string argument did not return NULL");
+    if (json_string_value(num) != NULL)
+        fail("json_string_value with non-string argument did not return NULL");
+
+    if (!json_string_setn_nocheck(NULL, "", 0))
+        fail("json_string_setn with non-string argument did not return error");
+    if (!json_string_setn_nocheck(num, "", 0))
+        fail("json_string_setn with non-string argument did not return error");
+    if (!json_string_setn_nocheck(txt, NULL, 0))
+        fail("json_string_setn_nocheck with NULL value did not return error");
+
+    if (!json_string_set_nocheck(txt, NULL))
+        fail("json_string_set_nocheck with NULL value did not return error");
+    if (!json_string_set(txt, NULL))
+        fail("json_string_set with NULL value did not return error");
+    if (!json_string_setn(txt, NULL, 0))
+        fail("json_string_setn with NULL value did not return error");
+
+    if (num->refcount != 1)
+        fail("unexpected reference count for num");
+    if (txt->refcount != 1)
+        fail("unexpected reference count for txt");
+
+    json_decref(num);
+    json_decref(txt);
+}
+
+/* Call the simple functions not covered by other tests of the public API */
+static void run_tests() {
+    json_t *value;
+
+    value = json_boolean(1);
+    if (!json_is_true(value))
+        fail("json_boolean(1) failed");
+    json_decref(value);
+
+    value = json_boolean(-123);
+    if (!json_is_true(value))
+        fail("json_boolean(-123) failed");
+    json_decref(value);
+
+    value = json_boolean(0);
+    if (!json_is_false(value))
+        fail("json_boolean(0) failed");
+    if (json_boolean_value(value) != 0)
+        fail("json_boolean_value failed");
+    json_decref(value);
+
+    value = json_integer(1);
+    if (json_typeof(value) != JSON_INTEGER)
+        fail("json_typeof failed");
+
+    if (json_is_object(value))
+        fail("json_is_object failed");
+
+    if (json_is_array(value))
+        fail("json_is_array failed");
+
+    if (json_is_string(value))
+        fail("json_is_string failed");
+
+    if (!json_is_integer(value))
+        fail("json_is_integer failed");
+
+    if (json_is_real(value))
+        fail("json_is_real failed");
+
+    if (!json_is_number(value))
+        fail("json_is_number failed");
+
+    if (json_is_true(value))
+        fail("json_is_true failed");
+
+    if (json_is_false(value))
+        fail("json_is_false failed");
+
+    if (json_is_boolean(value))
+        fail("json_is_boolean failed");
+
+    if (json_is_null(value))
+        fail("json_is_null failed");
+
+    json_decref(value);
+
+    value = json_string("foo");
+    if (!value)
+        fail("json_string failed");
+    if (strcmp(json_string_value(value), "foo"))
+        fail("invalid string value");
+    if (json_string_length(value) != 3)
+        fail("invalid string length");
+
+    if (json_string_set(value, "barr"))
+        fail("json_string_set failed");
+    if (strcmp(json_string_value(value), "barr"))
+        fail("invalid string value");
+    if (json_string_length(value) != 4)
+        fail("invalid string length");
+
+    if (json_string_setn(value, "hi\0ho", 5))
+        fail("json_string_set failed");
+    if (memcmp(json_string_value(value), "hi\0ho\0", 6))
+        fail("invalid string value");
+    if (json_string_length(value) != 5)
+        fail("invalid string length");
+
+    json_decref(value);
+
+    value = json_string(NULL);
+    if (value)
+        fail("json_string(NULL) failed");
+
+    /* invalid UTF-8  */
+    value = json_string("a\xefz");
+    if (value)
+        fail("json_string(<invalid utf-8>) failed");
+
+    value = json_string_nocheck("foo");
+    if (!value)
+        fail("json_string_nocheck failed");
+    if (strcmp(json_string_value(value), "foo"))
+        fail("invalid string value");
+    if (json_string_length(value) != 3)
+        fail("invalid string length");
+
+    if (json_string_set_nocheck(value, "barr"))
+        fail("json_string_set_nocheck failed");
+    if (strcmp(json_string_value(value), "barr"))
+        fail("invalid string value");
+    if (json_string_length(value) != 4)
+        fail("invalid string length");
+
+    if (json_string_setn_nocheck(value, "hi\0ho", 5))
+        fail("json_string_set failed");
+    if (memcmp(json_string_value(value), "hi\0ho\0", 6))
+        fail("invalid string value");
+    if (json_string_length(value) != 5)
+        fail("invalid string length");
+
+    json_decref(value);
+
+    /* invalid UTF-8 */
+    value = json_string_nocheck("qu\xff");
+    if (!value)
+        fail("json_string_nocheck failed");
+    if (strcmp(json_string_value(value), "qu\xff"))
+        fail("invalid string value");
+    if (json_string_length(value) != 3)
+        fail("invalid string length");
+
+    if (json_string_set_nocheck(value, "\xfd\xfe\xff"))
+        fail("json_string_set_nocheck failed");
+    if (strcmp(json_string_value(value), "\xfd\xfe\xff"))
+        fail("invalid string value");
+    if (json_string_length(value) != 3)
+        fail("invalid string length");
+
+    json_decref(value);
+
+    value = json_integer(123);
+    if (!value)
+        fail("json_integer failed");
+    if (json_integer_value(value) != 123)
+        fail("invalid integer value");
+    if (json_number_value(value) != 123.0)
+        fail("invalid number value");
+
+    if (json_integer_set(value, 321))
+        fail("json_integer_set failed");
+    if (json_integer_value(value) != 321)
+        fail("invalid integer value");
+    if (json_number_value(value) != 321.0)
+        fail("invalid number value");
+
+    json_decref(value);
+
+    value = json_real(123.123);
+    if (!value)
+        fail("json_real failed");
+    if (json_real_value(value) != 123.123)
+        fail("invalid integer value");
+    if (json_number_value(value) != 123.123)
+        fail("invalid number value");
+
+    if (json_real_set(value, 321.321))
+        fail("json_real_set failed");
+    if (json_real_value(value) != 321.321)
+        fail("invalid real value");
+    if (json_number_value(value) != 321.321)
+        fail("invalid number value");
+
+    json_decref(value);
+
+    value = json_true();
+    if (!value)
+        fail("json_true failed");
+    json_decref(value);
+
+    value = json_false();
+    if (!value)
+        fail("json_false failed");
+    json_decref(value);
+
+    value = json_null();
+    if (!value)
+        fail("json_null failed");
+    json_decref(value);
+
+    /* Test reference counting on singletons (true, false, null) */
+    value = json_true();
+    if (value->refcount != (size_t)-1)
+        fail("refcounting true works incorrectly");
+    json_decref(value);
+    if (value->refcount != (size_t)-1)
+        fail("refcounting true works incorrectly");
+    json_incref(value);
+    if (value->refcount != (size_t)-1)
+        fail("refcounting true works incorrectly");
+
+    value = json_false();
+    if (value->refcount != (size_t)-1)
+        fail("refcounting false works incorrectly");
+    json_decref(value);
+    if (value->refcount != (size_t)-1)
+        fail("refcounting false works incorrectly");
+    json_incref(value);
+    if (value->refcount != (size_t)-1)
+        fail("refcounting false works incorrectly");
+
+    value = json_null();
+    if (value->refcount != (size_t)-1)
+        fail("refcounting null works incorrectly");
+    json_decref(value);
+    if (value->refcount != (size_t)-1)
+        fail("refcounting null works incorrectly");
+    json_incref(value);
+    if (value->refcount != (size_t)-1)
+        fail("refcounting null works incorrectly");
+
+#ifdef json_auto_t
+    value = json_string("foo");
+    {
+        json_auto_t *test = json_incref(value);
+        /* Use test so GCC doesn't complain it is unused. */
+        if (!json_is_string(test))
+            fail("value type check failed");
+    }
+    if (value->refcount != 1)
+        fail("automatic decrement failed");
+    json_decref(value);
+#endif
+
+    test_bad_args();
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_sprintf.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_sprintf.c
new file mode 100644
index 000000000..60a0b601d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_sprintf.c
@@ -0,0 +1,29 @@
+#include "util.h"
+#include <jansson.h>
+#include <string.h>
+
+static void test_sprintf() {
+    json_t *s = json_sprintf("foo bar %d", 42);
+    if (!s)
+        fail("json_sprintf returned NULL");
+    if (!json_is_string(s))
+        fail("json_sprintf didn't return a JSON string");
+    if (strcmp(json_string_value(s), "foo bar 42"))
+        fail("json_sprintf generated an unexpected string");
+
+    json_decref(s);
+
+    s = json_sprintf("%s", "");
+    if (!s)
+        fail("json_sprintf returned NULL");
+    if (!json_is_string(s))
+        fail("json_sprintf didn't return a JSON string");
+    if (json_string_length(s) != 0)
+        fail("string is not empty");
+    json_decref(s);
+
+    if (json_sprintf("%s", "\xff\xff"))
+        fail("json_sprintf unexpected success with invalid UTF");
+}
+
+static void run_tests() { test_sprintf(); }
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_unpack.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_unpack.c
new file mode 100644
index 000000000..139ec6f7b
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_unpack.c
@@ -0,0 +1,431 @@
+/*
+ * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+ * Copyright (c) 2010-2012 Graeme Smecher <graeme.smecher@mail.mcgill.ca>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "util.h"
+#include <jansson.h>
+#include <stdio.h>
+#include <string.h>
+
+static void run_tests() {
+    json_t *j, *j2;
+    int i1, i2, i3;
+    json_int_t I1;
+    int rv;
+    size_t z;
+    double f;
+    char *s;
+
+    json_error_t error;
+
+    /*
+     * Simple, valid json_pack cases
+     */
+
+    /* true */
+    rv = json_unpack(json_true(), "b", &i1);
+    if (rv || !i1)
+        fail("json_unpack boolean failed");
+
+    /* false */
+    rv = json_unpack(json_false(), "b", &i1);
+    if (rv || i1)
+        fail("json_unpack boolean failed");
+
+    /* null */
+    if (json_unpack(json_null(), "n"))
+        fail("json_unpack null failed");
+
+    /* integer */
+    j = json_integer(42);
+    rv = json_unpack(j, "i", &i1);
+    if (rv || i1 != 42)
+        fail("json_unpack integer failed");
+    json_decref(j);
+
+    /* json_int_t */
+    j = json_integer(5555555);
+    rv = json_unpack(j, "I", &I1);
+    if (rv || I1 != 5555555)
+        fail("json_unpack json_int_t failed");
+    json_decref(j);
+
+    /* real */
+    j = json_real(1.7);
+    rv = json_unpack(j, "f", &f);
+    if (rv || f != 1.7)
+        fail("json_unpack real failed");
+    json_decref(j);
+
+    /* number */
+    j = json_integer(12345);
+    rv = json_unpack(j, "F", &f);
+    if (rv || f != 12345.0)
+        fail("json_unpack (real or) integer failed");
+    json_decref(j);
+
+    j = json_real(1.7);
+    rv = json_unpack(j, "F", &f);
+    if (rv || f != 1.7)
+        fail("json_unpack real (or integer) failed");
+    json_decref(j);
+
+    /* string */
+    j = json_string("foo");
+    rv = json_unpack(j, "s", &s);
+    if (rv || strcmp(s, "foo"))
+        fail("json_unpack string failed");
+    json_decref(j);
+
+    /* string with length (size_t) */
+    j = json_string("foo");
+    rv = json_unpack(j, "s%", &s, &z);
+    if (rv || strcmp(s, "foo") || z != 3)
+        fail("json_unpack string with length (size_t) failed");
+    json_decref(j);
+
+    /* empty object */
+    j = json_object();
+    if (json_unpack(j, "{}"))
+        fail("json_unpack empty object failed");
+    json_decref(j);
+
+    /* empty list */
+    j = json_array();
+    if (json_unpack(j, "[]"))
+        fail("json_unpack empty list failed");
+    json_decref(j);
+
+    /* non-incref'd object */
+    j = json_object();
+    rv = json_unpack(j, "o", &j2);
+    if (rv || j2 != j || j->refcount != 1)
+        fail("json_unpack object failed");
+    json_decref(j);
+
+    /* incref'd object */
+    j = json_object();
+    rv = json_unpack(j, "O", &j2);
+    if (rv || j2 != j || j->refcount != 2)
+        fail("json_unpack object failed");
+    json_decref(j);
+    json_decref(j);
+
+    /* simple object */
+    j = json_pack("{s:i}", "foo", 42);
+    rv = json_unpack(j, "{s:i}", "foo", &i1);
+    if (rv || i1 != 42)
+        fail("json_unpack simple object failed");
+    json_decref(j);
+
+    /* simple array */
+    j = json_pack("[iii]", 1, 2, 3);
+    rv = json_unpack(j, "[i,i,i]", &i1, &i2, &i3);
+    if (rv || i1 != 1 || i2 != 2 || i3 != 3)
+        fail("json_unpack simple array failed");
+    json_decref(j);
+
+    /* object with many items & strict checking */
+    j = json_pack("{s:i, s:i, s:i}", "a", 1, "b", 2, "c", 3);
+    rv = json_unpack(j, "{s:i, s:i, s:i}", "a", &i1, "b", &i2, "c", &i3);
+    if (rv || i1 != 1 || i2 != 2 || i3 != 3)
+        fail("json_unpack object with many items failed");
+    json_decref(j);
+
+    /*
+     * Invalid cases
+     */
+
+    j = json_integer(42);
+    if (!json_unpack_ex(j, &error, 0, "z"))
+        fail("json_unpack succeeded with invalid format character");
+    check_error(json_error_invalid_format, "Unexpected format character 'z'", "<format>",
+                1, 1, 1);
+
+    if (!json_unpack_ex(NULL, &error, 0, "[i]"))
+        fail("json_unpack succeeded with NULL root");
+    check_error(json_error_null_value, "NULL root value", "<root>", -1, -1, 0);
+    json_decref(j);
+
+    /* mismatched open/close array/object */
+    j = json_pack("[]");
+    if (!json_unpack_ex(j, &error, 0, "[}"))
+        fail("json_unpack failed to catch mismatched ']'");
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>",
+                1, 2, 2);
+    json_decref(j);
+
+    j = json_pack("{}");
+    if (!json_unpack_ex(j, &error, 0, "{]"))
+        fail("json_unpack failed to catch mismatched '}'");
+    check_error(json_error_invalid_format, "Expected format 's', got ']'", "<format>", 1,
+                2, 2);
+    json_decref(j);
+
+    /* missing close array */
+    j = json_pack("[]");
+    if (!json_unpack_ex(j, &error, 0, "["))
+        fail("json_unpack failed to catch missing ']'");
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>",
+                1, 2, 2);
+    json_decref(j);
+
+    /* missing close object */
+    j = json_pack("{}");
+    if (!json_unpack_ex(j, &error, 0, "{"))
+        fail("json_unpack failed to catch missing '}'");
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>",
+                1, 2, 2);
+    json_decref(j);
+
+    /* garbage after format string */
+    j = json_pack("[i]", 42);
+    if (!json_unpack_ex(j, &error, 0, "[i]a", &i1))
+        fail("json_unpack failed to catch garbage after format string");
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1,
+                4, 4);
+    json_decref(j);
+
+    j = json_integer(12345);
+    if (!json_unpack_ex(j, &error, 0, "ia", &i1))
+        fail("json_unpack failed to catch garbage after format string");
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1,
+                2, 2);
+    json_decref(j);
+
+    /* NULL format string */
+    j = json_pack("[]");
+    if (!json_unpack_ex(j, &error, 0, NULL))
+        fail("json_unpack failed to catch null format string");
+    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>",
+                -1, -1, 0);
+    json_decref(j);
+
+    /* NULL string pointer */
+    j = json_string("foobie");
+    if (!json_unpack_ex(j, &error, 0, "s", NULL))
+        fail("json_unpack failed to catch null string pointer");
+    check_error(json_error_null_value, "NULL string argument", "<args>", 1, 1, 1);
+    json_decref(j);
+
+    /* invalid types */
+    j = json_integer(42);
+    j2 = json_string("foo");
+    if (!json_unpack_ex(j, &error, 0, "s"))
+        fail("json_unpack failed to catch invalid type");
+    check_error(json_error_wrong_type, "Expected string, got integer", "<validation>", 1,
+                1, 1);
+
+    if (!json_unpack_ex(j, &error, 0, "n"))
+        fail("json_unpack failed to catch invalid type");
+    check_error(json_error_wrong_type, "Expected null, got integer", "<validation>", 1, 1,
+                1);
+
+    if (!json_unpack_ex(j, &error, 0, "b"))
+        fail("json_unpack failed to catch invalid type");
+    check_error(json_error_wrong_type, "Expected true or false, got integer",
+                "<validation>", 1, 1, 1);
+
+    if (!json_unpack_ex(j2, &error, 0, "i"))
+        fail("json_unpack failed to catch invalid type");
+    check_error(json_error_wrong_type, "Expected integer, got string", "<validation>", 1,
+                1, 1);
+
+    if (!json_unpack_ex(j2, &error, 0, "I"))
+        fail("json_unpack failed to catch invalid type");
+    check_error(json_error_wrong_type, "Expected integer, got string", "<validation>", 1,
+                1, 1);
+
+    if (!json_unpack_ex(j, &error, 0, "f"))
+        fail("json_unpack failed to catch invalid type");
+    check_error(json_error_wrong_type, "Expected real, got integer", "<validation>", 1, 1,
+                1);
+
+    if (!json_unpack_ex(j2, &error, 0, "F"))
+        fail("json_unpack failed to catch invalid type");
+    check_error(json_error_wrong_type, "Expected real or integer, got string",
+                "<validation>", 1, 1, 1);
+
+    if (!json_unpack_ex(j, &error, 0, "[i]"))
+        fail("json_unpack failed to catch invalid type");
+    check_error(json_error_wrong_type, "Expected array, got integer", "<validation>", 1,
+                1, 1);
+
+    if (!json_unpack_ex(j, &error, 0, "{si}", "foo"))
+        fail("json_unpack failed to catch invalid type");
+    check_error(json_error_wrong_type, "Expected object, got integer", "<validation>", 1,
+                1, 1);
+
+    json_decref(j);
+    json_decref(j2);
+
+    /* Array index out of range */
+    j = json_pack("[i]", 1);
+    if (!json_unpack_ex(j, &error, 0, "[ii]", &i1, &i2))
+        fail("json_unpack failed to catch index out of array bounds");
+    check_error(json_error_index_out_of_range, "Array index 1 out of range",
+                "<validation>", 1, 3, 3);
+    json_decref(j);
+
+    /* NULL object key */
+    j = json_pack("{si}", "foo", 42);
+    if (!json_unpack_ex(j, &error, 0, "{si}", NULL, &i1))
+        fail("json_unpack failed to catch null string pointer");
+    check_error(json_error_null_value, "NULL object key", "<args>", 1, 2, 2);
+    json_decref(j);
+
+    /* Object key not found */
+    j = json_pack("{si}", "foo", 42);
+    if (!json_unpack_ex(j, &error, 0, "{si}", "baz", &i1))
+        fail("json_unpack failed to catch null string pointer");
+    check_error(json_error_item_not_found, "Object item not found: baz", "<validation>",
+                1, 3, 3);
+    json_decref(j);
+
+    /*
+     * Strict validation
+     */
+
+    j = json_pack("[iii]", 1, 2, 3);
+    rv = json_unpack(j, "[iii!]", &i1, &i2, &i3);
+    if (rv || i1 != 1 || i2 != 2 || i3 != 3)
+        fail("json_unpack array with strict validation failed");
+    json_decref(j);
+
+    j = json_pack("[iii]", 1, 2, 3);
+    if (!json_unpack_ex(j, &error, 0, "[ii!]", &i1, &i2))
+        fail("json_unpack array with strict validation failed");
+    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked",
+                "<validation>", 1, 5, 5);
+    json_decref(j);
+
+    /* Like above, but with JSON_STRICT instead of '!' format */
+    j = json_pack("[iii]", 1, 2, 3);
+    if (!json_unpack_ex(j, &error, JSON_STRICT, "[ii]", &i1, &i2))
+        fail("json_unpack array with strict validation failed");
+    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked",
+                "<validation>", 1, 4, 4);
+    json_decref(j);
+
+    j = json_pack("{s:s, s:i}", "foo", "bar", "baz", 42);
+    rv = json_unpack(j, "{sssi!}", "foo", &s, "baz", &i1);
+    if (rv || strcmp(s, "bar") != 0 || i1 != 42)
+        fail("json_unpack object with strict validation failed");
+    json_decref(j);
+
+    /* Unpack the same item twice */
+    j = json_pack("{s:s, s:i, s:b}", "foo", "bar", "baz", 42, "quux", 1);
+    if (!json_unpack_ex(j, &error, 0, "{s:s,s:s!}", "foo", &s, "foo", &s))
+        fail("json_unpack object with strict validation failed");
+    {
+        const char *possible_errors[] = {"2 object item(s) left unpacked: baz, quux",
+                                         "2 object item(s) left unpacked: quux, baz"};
+        check_errors(json_error_end_of_input_expected, possible_errors, 2, "<validation>",
+                     1, 10, 10);
+    }
+    json_decref(j);
+
+    j = json_pack("[i,{s:i,s:n},[i,i]]", 1, "foo", 2, "bar", 3, 4);
+    if (json_unpack_ex(j, NULL, JSON_STRICT | JSON_VALIDATE_ONLY, "[i{sisn}[ii]]", "foo",
+                       "bar"))
+        fail("json_unpack complex value with strict validation failed");
+    json_decref(j);
+
+    /* ! and * must be last */
+    j = json_pack("[ii]", 1, 2);
+    if (!json_unpack_ex(j, &error, 0, "[i!i]", &i1, &i2))
+        fail("json_unpack failed to catch ! in the middle of an array");
+    check_error(json_error_invalid_format, "Expected ']' after '!', got 'i'", "<format>",
+                1, 4, 4);
+
+    if (!json_unpack_ex(j, &error, 0, "[i*i]", &i1, &i2))
+        fail("json_unpack failed to catch * in the middle of an array");
+    check_error(json_error_invalid_format, "Expected ']' after '*', got 'i'", "<format>",
+                1, 4, 4);
+    json_decref(j);
+
+    j = json_pack("{sssi}", "foo", "bar", "baz", 42);
+    if (!json_unpack_ex(j, &error, 0, "{ss!si}", "foo", &s, "baz", &i1))
+        fail("json_unpack failed to catch ! in the middle of an object");
+    check_error(json_error_invalid_format, "Expected '}' after '!', got 's'", "<format>",
+                1, 5, 5);
+
+    if (!json_unpack_ex(j, &error, 0, "{ss*si}", "foo", &s, "baz", &i1))
+        fail("json_unpack failed to catch ! in the middle of an object");
+    check_error(json_error_invalid_format, "Expected '}' after '*', got 's'", "<format>",
+                1, 5, 5);
+    json_decref(j);
+
+    /* Error in nested object */
+    j = json_pack("{s{snsn}}", "foo", "bar", "baz");
+    if (!json_unpack_ex(j, &error, 0, "{s{sn!}}", "foo", "bar"))
+        fail("json_unpack nested object with strict validation failed");
+    check_error(json_error_end_of_input_expected, "1 object item(s) left unpacked: baz",
+                "<validation>", 1, 7, 7);
+    json_decref(j);
+
+    /* Error in nested array */
+    j = json_pack("[[ii]]", 1, 2);
+    if (!json_unpack_ex(j, &error, 0, "[[i!]]", &i1))
+        fail("json_unpack nested array with strict validation failed");
+    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked",
+                "<validation>", 1, 5, 5);
+    json_decref(j);
+
+    /* Optional values */
+    j = json_object();
+    i1 = 0;
+    if (json_unpack(j, "{s?i}", "foo", &i1))
+        fail("json_unpack failed for optional key");
+    if (i1 != 0)
+        fail("json_unpack unpacked an optional key");
+    json_decref(j);
+
+    i1 = 0;
+    j = json_pack("{si}", "foo", 42);
+    if (json_unpack(j, "{s?i}", "foo", &i1))
+        fail("json_unpack failed for an optional value");
+    if (i1 != 42)
+        fail("json_unpack failed to unpack an optional value");
+    json_decref(j);
+
+    j = json_object();
+    i1 = i2 = i3 = 0;
+    if (json_unpack(j, "{s?[ii]s?{s{si}}}", "foo", &i1, &i2, "bar", "baz", "quux", &i3))
+        fail("json_unpack failed for complex optional values");
+    if (i1 != 0 || i2 != 0 || i3 != 0)
+        fail("json_unpack unexpectedly unpacked something");
+    json_decref(j);
+
+    j = json_pack("{s{si}}", "foo", "bar", 42);
+    if (json_unpack(j, "{s?{s?i}}", "foo", "bar", &i1))
+        fail("json_unpack failed for complex optional values");
+    if (i1 != 42)
+        fail("json_unpack failed to unpack");
+    json_decref(j);
+
+    /* Combine ? and ! */
+    j = json_pack("{si}", "foo", 42);
+    i1 = i2 = 0;
+    if (json_unpack(j, "{sis?i!}", "foo", &i1, "bar", &i2))
+        fail("json_unpack failed for optional values with strict mode");
+    if (i1 != 42)
+        fail("json_unpack failed to unpack");
+    if (i2 != 0)
+        fail("json_unpack failed to unpack");
+    json_decref(j);
+
+    /* But don't compensate a missing key with an optional one. */
+    j = json_pack("{sisi}", "foo", 42, "baz", 43);
+    i1 = i2 = i3 = 0;
+    if (!json_unpack_ex(j, &error, 0, "{sis?i!}", "foo", &i1, "bar", &i2))
+        fail("json_unpack failed for optional values with strict mode and "
+             "compensation");
+    check_error(json_error_end_of_input_expected, "1 object item(s) left unpacked: baz",
+                "<validation>", 1, 8, 8);
+    json_decref(j);
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_version.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_version.c
new file mode 100644
index 000000000..05e0e9614
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_version.c
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2019 Sean Bright <sean.bright@gmail.com>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "util.h"
+#include <jansson.h>
+#include <string.h>
+
+static void test_version_str(void) {
+    if (strcmp(jansson_version_str(), JANSSON_VERSION)) {
+        fail("jansson_version_str returned invalid version string");
+    }
+}
+
+static void test_version_cmp() {
+    if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION,
+                            JANSSON_MICRO_VERSION)) {
+        fail("jansson_version_cmp equality check failed");
+    }
+
+    if (jansson_version_cmp(JANSSON_MAJOR_VERSION - 1, 0, 0) <= 0) {
+        fail("jansson_version_cmp less than check failed");
+    }
+
+    if (JANSSON_MINOR_VERSION) {
+        if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION - 1,
+                                JANSSON_MICRO_VERSION) <= 0) {
+            fail("jansson_version_cmp less than check failed");
+        }
+    }
+
+    if (JANSSON_MICRO_VERSION) {
+        if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION,
+                                JANSSON_MICRO_VERSION - 1) <= 0) {
+            fail("jansson_version_cmp less than check failed");
+        }
+    }
+
+    if (jansson_version_cmp(JANSSON_MAJOR_VERSION + 1, JANSSON_MINOR_VERSION,
+                            JANSSON_MICRO_VERSION) >= 0) {
+        fail("jansson_version_cmp greater than check failed");
+    }
+
+    if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION + 1,
+                            JANSSON_MICRO_VERSION) >= 0) {
+        fail("jansson_version_cmp greater than check failed");
+    }
+
+    if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION,
+                            JANSSON_MICRO_VERSION + 1) >= 0) {
+        fail("jansson_version_cmp greater than check failed");
+    }
+}
+
+static void run_tests() {
+    test_version_str();
+    test_version_cmp();
+}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/util.h b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/util.h
new file mode 100644
index 000000000..d964c4930
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/util.h
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+ *
+ * Jansson is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#ifndef UTIL_H
+#define UTIL_H
+
+#ifdef HAVE_CONFIG_H
+#include <jansson_private_config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#if HAVE_LOCALE_H
+#include <locale.h>
+#endif
+
+#include <jansson.h>
+
+#define failhdr fprintf(stderr, "%s:%d: ", __FILE__, __LINE__)
+
+#define fail(msg)                                                                        \
+    do {                                                                                 \
+        failhdr;                                                                         \
+        fprintf(stderr, "%s\n", msg);                                                    \
+        exit(1);                                                                         \
+    } while (0)
+
+/* Assumes json_error_t error */
+#define check_errors(code_, texts_, num_, source_, line_, column_, position_)            \
+    do {                                                                                 \
+        int i_, found_ = 0;                                                              \
+        if (json_error_code(&error) != code_) {                                          \
+            failhdr;                                                                     \
+            fprintf(stderr, "code: %d != %d\n", json_error_code(&error), code_);         \
+            exit(1);                                                                     \
+        }                                                                                \
+        for (i_ = 0; i_ < num_; i_++) {                                                  \
+            if (strcmp(error.text, texts_[i_]) == 0) {                                   \
+                found_ = 1;                                                              \
+                break;                                                                   \
+            }                                                                            \
+        }                                                                                \
+        if (!found_) {                                                                   \
+            failhdr;                                                                     \
+            if (num_ == 1) {                                                             \
+                fprintf(stderr, "text: \"%s\" != \"%s\"\n", error.text, texts_[0]);      \
+            } else {                                                                     \
+                fprintf(stderr, "text: \"%s\" does not match\n", error.text);            \
+            }                                                                            \
+            exit(1);                                                                     \
+        }                                                                                \
+        if (strcmp(error.source, source_) != 0) {                                        \
+            failhdr;                                                                     \
+                                                                                         \
+            fprintf(stderr, "source: \"%s\" != \"%s\"\n", error.source, source_);        \
+            exit(1);                                                                     \
+        }                                                                                \
+        if (error.line != line_) {                                                       \
+            failhdr;                                                                     \
+            fprintf(stderr, "line: %d != %d\n", error.line, line_);                      \
+            exit(1);                                                                     \
+        }                                                                                \
+        if (error.column != column_) {                                                   \
+            failhdr;                                                                     \
+            fprintf(stderr, "column: %d != %d\n", error.column, column_);                \
+            exit(1);                                                                     \
+        }                                                                                \
+        if (error.position != position_) {                                               \
+            failhdr;                                                                     \
+            fprintf(stderr, "position: %d != %d\n", error.position, position_);          \
+            exit(1);                                                                     \
+        }                                                                                \
+    } while (0)
+
+/* Assumes json_error_t error */
+#define check_error(code_, text_, source_, line_, column_, position_)                    \
+    check_errors(code_, &text_, 1, source_, line_, column_, position_)
+
+static void run_tests();
+
+int main() {
+#ifdef HAVE_SETLOCALE
+    setlocale(LC_ALL, "");
+#endif
+    run_tests();
+    return 0;
+}
+
+#endif
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/array/input
new file mode 100644
index 000000000..44e2ace7e
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/array/input
@@ -0,0 +1 @@
+[1, 2]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/array/output
new file mode 100644
index 000000000..fd8ef0957
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/array/output
@@ -0,0 +1 @@
+[1, 2]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/env
new file mode 100644
index 000000000..4474aaf14
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/env
@@ -0,0 +1,2 @@
+JSON_COMPACT=1
+export JSON_COMPACT
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/input
new file mode 100644
index 000000000..44e2ace7e
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/input
@@ -0,0 +1 @@
+[1, 2]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/output
new file mode 100644
index 000000000..3169929f6
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/output
@@ -0,0 +1 @@
+[1,2]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/env
new file mode 100644
index 000000000..93cb33dda
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/env
@@ -0,0 +1,3 @@
+JSON_COMPACT=1
+HASHSEED=1
+export JSON_COMPACT HASHSEED
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/input
new file mode 100644
index 000000000..062e54fb4
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/input
@@ -0,0 +1 @@
+{"a": 1, "b": 2}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/output
new file mode 100644
index 000000000..73a5d70e3
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/output
@@ -0,0 +1 @@
+{"a":1,"b":2}
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/env
new file mode 100644
index 000000000..1b7b3e3f9
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/env
@@ -0,0 +1,2 @@
+JSON_ENSURE_ASCII=1
+export JSON_ENSURE_ASCII
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/input
new file mode 100644
index 000000000..69469cef5
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/input
@@ -0,0 +1,8 @@
+[
+    "foo",
+    "å ä ö",
+    "foo åä",
+    "åä foo",
+    "å foo ä",
+    "clef g: 𝄞"
+]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/output
new file mode 100644
index 000000000..94fa79d2d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/output
@@ -0,0 +1 @@
+["foo", "\u00E5 \u00E4 \u00F6", "foo \u00E5\u00E4", "\u00E5\u00E4 foo", "\u00E5 foo \u00E4", "clef g: \uD834\uDD1E"]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/env
new file mode 100644
index 000000000..d220f837c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/env
@@ -0,0 +1,2 @@
+JSON_INDENT=4
+export JSON_INDENT
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/input
new file mode 100644
index 000000000..44e2ace7e
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/input
@@ -0,0 +1 @@
+[1, 2]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/output
new file mode 100644
index 000000000..c57d705ba
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/output
@@ -0,0 +1,4 @@
+[
+    1,
+    2
+]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/env
new file mode 100644
index 000000000..78fbfcc2e
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/env
@@ -0,0 +1,3 @@
+JSON_INDENT=4
+JSON_COMPACT=1
+export JSON_INDENT JSON_COMPACT
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/input
new file mode 100644
index 000000000..44e2ace7e
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/input
@@ -0,0 +1 @@
+[1, 2]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/output
new file mode 100644
index 000000000..c57d705ba
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/output
@@ -0,0 +1,4 @@
+[
+    1,
+    2
+]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/env
new file mode 100644
index 000000000..c73acc179
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/env
@@ -0,0 +1,4 @@
+JSON_INDENT=4
+JSON_COMPACT=1
+HASHSEED=1
+export JSON_INDENT JSON_COMPACT HASHSEED
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/input
new file mode 100644
index 000000000..062e54fb4
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/input
@@ -0,0 +1 @@
+{"a": 1, "b": 2}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/output
new file mode 100644
index 000000000..9cc42948d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/output
@@ -0,0 +1,4 @@
+{
+    "a":1,
+    "b":2
+}
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/env
new file mode 100644
index 000000000..961558ca2
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/env
@@ -0,0 +1,3 @@
+JSON_INDENT=4
+HASHSEED=1
+export JSON_INDENT HASHSEED
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/input
new file mode 100644
index 000000000..062e54fb4
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/input
@@ -0,0 +1 @@
+{"a": 1, "b": 2}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/output
new file mode 100644
index 000000000..0fbddba44
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/output
@@ -0,0 +1,4 @@
+{
+    "a": 1,
+    "b": 2
+}
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/env
new file mode 100644
index 000000000..9120b0351
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/env
@@ -0,0 +1,2 @@
+HASHSEED=1
+export HASHSEED
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/input
new file mode 100644
index 000000000..062e54fb4
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/input
@@ -0,0 +1 @@
+{"a": 1, "b": 2}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/output
new file mode 100644
index 000000000..ecd219f72
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/output
@@ -0,0 +1 @@
+{"a": 1, "b": 2}
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/env
new file mode 100644
index 000000000..4d9d20659
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/env
@@ -0,0 +1,2 @@
+JSON_PRESERVE_ORDER=1
+export JSON_PRESERVE_ORDER
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/input
new file mode 100644
index 000000000..27bcf18a0
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/input
@@ -0,0 +1 @@
+{"foo": 1, "bar": 2, "asdf": 3, "deadbeef": 4, "badc0ffee": 5, "qwerty": 6}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/output
new file mode 100644
index 000000000..7a443f684
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/output
@@ -0,0 +1 @@
+{"foo": 1, "bar": 2, "asdf": 3, "deadbeef": 4, "badc0ffee": 5, "qwerty": 6}
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/env
new file mode 100644
index 000000000..9c52cbcd6
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/env
@@ -0,0 +1,2 @@
+JSON_REAL_PRECISION=4
+export JSON_REAL_PRECISION
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/input
new file mode 100644
index 000000000..e291165c1
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/input
@@ -0,0 +1 @@
+[1.23456789, 1.0, 1.0000000000000002]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/output
new file mode 100644
index 000000000..f273c73e5
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/output
@@ -0,0 +1 @@
+[1.235, 1.0, 1.0]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/run b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/run
new file mode 100755
index 000000000..5db7d5e5c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/run
@@ -0,0 +1,32 @@
+#!/bin/sh
+#
+# Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+#
+# Jansson is free software; you can redistribute it and/or modify
+# it under the terms of the MIT license. See LICENSE for details.
+
+is_test() {
+    test -d $test_path
+}
+
+run_test() {
+    (
+        if [ -f $test_path/env ]; then
+            . $test_path/env
+        fi
+        $json_process --env <$test_path/input >$test_log/stdout 2>$test_log/stderr
+    )
+    valgrind_check $test_log/stderr || return 1
+    cmp -s $test_path/output $test_log/stdout
+}
+
+show_error() {
+    valgrind_show_error && return
+
+    echo "EXPECTED OUTPUT:"
+    nl -bn $test_path/output
+    echo "ACTUAL OUTPUT:"
+    nl -bn $test_log/stdout
+}
+
+. $top_srcdir/test/scripts/run-tests.sh
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/env
new file mode 100644
index 000000000..3ef24cb7b
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/env
@@ -0,0 +1,2 @@
+JSON_SORT_KEYS=1
+export JSON_SORT_KEYS
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/input
new file mode 100644
index 000000000..66951d6b0
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/input
@@ -0,0 +1 @@
+{"foo": 1, "bar": 2, "baz": 3, "quux": 4}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/output
new file mode 100644
index 000000000..132d9df31
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/output
@@ -0,0 +1 @@
+{"bar": 2, "baz": 3, "foo": 1, "quux": 4}
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/encoded-surrogate-half/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/encoded-surrogate-half/error
new file mode 100644
index 000000000..762d2c4b1
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/encoded-surrogate-half/error
@@ -0,0 +1,2 @@
+1 2 2
+unable to decode byte 0xed near '"'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/encoded-surrogate-half/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/encoded-surrogate-half/input
new file mode 100644
index 000000000..515dd933c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/encoded-surrogate-half/input
@@ -0,0 +1 @@
+["��� <-- encoded surrogate half"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-after-backslash/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-after-backslash/error
new file mode 100644
index 000000000..b16dc171e
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-after-backslash/error
@@ -0,0 +1,2 @@
+1 3 3
+unable to decode byte 0xe5 near '"\'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-after-backslash/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-after-backslash/input
new file mode 100644
index 000000000..57c8beef6
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-after-backslash/input
@@ -0,0 +1 @@
+["\�"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-array/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-array/error
new file mode 100644
index 000000000..be15386df
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-array/error
@@ -0,0 +1,2 @@
+1 1 1
+unable to decode byte 0xe5
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-array/input
new file mode 100644
index 000000000..ebefcd6f8
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-array/input
@@ -0,0 +1 @@
+[�]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-bigger-int/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-bigger-int/error
new file mode 100644
index 000000000..01b447639
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-bigger-int/error
@@ -0,0 +1,2 @@
+1 4 4
+unable to decode byte 0xe5 near '123'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-bigger-int/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-bigger-int/input
new file mode 100644
index 000000000..e512f9ae0
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-bigger-int/input
@@ -0,0 +1 @@
+[123�]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-escape/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-escape/error
new file mode 100644
index 000000000..c13583dd8
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-escape/error
@@ -0,0 +1,2 @@
+1 4 4
+unable to decode byte 0xe5 near '"\u'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-escape/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-escape/input
new file mode 100644
index 000000000..2b271b82f
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-escape/input
@@ -0,0 +1 @@
+["\u�"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-exponent/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-exponent/error
new file mode 100644
index 000000000..c7b20b7a2
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-exponent/error
@@ -0,0 +1,2 @@
+1 4 4
+unable to decode byte 0xe5 near '1e1'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-exponent/input
new file mode 100644
index 000000000..d8e83c595
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-exponent/input
@@ -0,0 +1 @@
+[1e1�]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-identifier/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-identifier/error
new file mode 100644
index 000000000..33dfc2324
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-identifier/error
@@ -0,0 +1,2 @@
+1 2 2
+unable to decode byte 0xe5 near 'a'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-identifier/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-identifier/input
new file mode 100644
index 000000000..ef038514a
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-identifier/input
@@ -0,0 +1 @@
+[a�]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-int/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-int/error
new file mode 100644
index 000000000..8f08970c1
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-int/error
@@ -0,0 +1,2 @@
+1 2 2
+unable to decode byte 0xe5 near '0'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-int/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-int/input
new file mode 100644
index 000000000..371226e4c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-int/input
@@ -0,0 +1 @@
+[0�]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-real-after-e/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-real-after-e/error
new file mode 100644
index 000000000..b7660e327
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-real-after-e/error
@@ -0,0 +1,2 @@
+1 3 3
+unable to decode byte 0xe5 near '1e'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-real-after-e/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-real-after-e/input
new file mode 100644
index 000000000..17fc29c90
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-real-after-e/input
@@ -0,0 +1 @@
+[1e�]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-string/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-string/error
new file mode 100644
index 000000000..0b7039a52
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-string/error
@@ -0,0 +1,2 @@
+1 2 2
+unable to decode byte 0xe5 near '"'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-string/input
new file mode 100644
index 000000000..00b79c0af
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-string/input
@@ -0,0 +1 @@
+["� <-- invalid UTF-8"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-invalid-utf-8/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-invalid-utf-8/error
new file mode 100644
index 000000000..8e9a51119
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-invalid-utf-8/error
@@ -0,0 +1,2 @@
+1 0 0
+unable to decode byte 0xe5
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-invalid-utf-8/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-invalid-utf-8/input
new file mode 100644
index 000000000..eb8079699
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-invalid-utf-8/input
@@ -0,0 +1 @@
+�
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-utf-8-continuation-byte/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-utf-8-continuation-byte/error
new file mode 100644
index 000000000..86bbad3c8
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-utf-8-continuation-byte/error
@@ -0,0 +1,2 @@
+1 2 2
+unable to decode byte 0x81 near '"'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-utf-8-continuation-byte/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-utf-8-continuation-byte/input
new file mode 100644
index 000000000..62a26b6fb
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-utf-8-continuation-byte/input
@@ -0,0 +1 @@
+["�"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/not-in-unicode-range/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/not-in-unicode-range/error
new file mode 100644
index 000000000..d07ccb3e5
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/not-in-unicode-range/error
@@ -0,0 +1,2 @@
+1 2 2
+unable to decode byte 0xf4 near '"'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/not-in-unicode-range/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/not-in-unicode-range/input
new file mode 100644
index 000000000..1216186a7
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/not-in-unicode-range/input
@@ -0,0 +1 @@
+["����"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-3-byte-encoding/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-3-byte-encoding/error
new file mode 100644
index 000000000..8a05abaed
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-3-byte-encoding/error
@@ -0,0 +1,2 @@
+1 2 2
+unable to decode byte 0xe0 near '"'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-3-byte-encoding/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-3-byte-encoding/input
new file mode 100644
index 000000000..0bf909f7b
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-3-byte-encoding/input
@@ -0,0 +1 @@
+["��� <-- overlong encoding"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-4-byte-encoding/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-4-byte-encoding/error
new file mode 100644
index 000000000..7e19c5fe4
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-4-byte-encoding/error
@@ -0,0 +1,2 @@
+1 2 2
+unable to decode byte 0xf0 near '"'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-4-byte-encoding/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-4-byte-encoding/input
new file mode 100644
index 000000000..c6b631350
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-4-byte-encoding/input
@@ -0,0 +1 @@
+["���� <-- overlong encoding"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-ascii-encoding/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-ascii-encoding/error
new file mode 100644
index 000000000..1d382edd7
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-ascii-encoding/error
@@ -0,0 +1,2 @@
+1 2 2
+unable to decode byte 0xc1 near '"'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-ascii-encoding/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-ascii-encoding/input
new file mode 100644
index 000000000..ef6e10a34
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-ascii-encoding/input
@@ -0,0 +1 @@
+["�"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/restricted-utf-8/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/restricted-utf-8/error
new file mode 100644
index 000000000..d018f5ff3
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/restricted-utf-8/error
@@ -0,0 +1,2 @@
+1 2 2
+unable to decode byte 0xfd near '"'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/restricted-utf-8/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/restricted-utf-8/input
new file mode 100644
index 000000000..ba6017002
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/restricted-utf-8/input
@@ -0,0 +1 @@
+["�"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/run b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/run
new file mode 100755
index 000000000..369c43da5
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/run
@@ -0,0 +1,27 @@
+#!/bin/sh
+#
+# Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+#
+# Jansson is free software; you can redistribute it and/or modify
+# it under the terms of the MIT license. See LICENSE for details.
+
+is_test() {
+    test -d $test_path
+}
+
+run_test() {
+    $json_process --env <$test_path/input >$test_log/stdout 2>$test_log/stderr
+    valgrind_check $test_log/stderr || return 1
+    cmp -s $test_path/error $test_log/stderr
+}
+
+show_error() {
+    valgrind_show_error && return
+
+    echo "EXPECTED ERROR:"
+    nl -bn $test_path/error
+    echo "ACTUAL ERROR:"
+    nl -bn $test_log/stderr
+}
+
+. $top_srcdir/test/scripts/run-tests.sh
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/truncated-utf-8/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/truncated-utf-8/error
new file mode 100644
index 000000000..8a05abaed
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/truncated-utf-8/error
@@ -0,0 +1,2 @@
+1 2 2
+unable to decode byte 0xe0 near '"'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/truncated-utf-8/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/truncated-utf-8/input
new file mode 100644
index 000000000..bce9e18bf
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/truncated-utf-8/input
@@ -0,0 +1 @@
+["�� <-- truncated UTF-8"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/apostrophe/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/apostrophe/error
new file mode 100644
index 000000000..79bb2a0eb
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/apostrophe/error
@@ -0,0 +1,2 @@
+1 2 2
+invalid token near '''
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/apostrophe/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/apostrophe/input
new file mode 100644
index 000000000..f2dd4d224
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/apostrophe/input
@@ -0,0 +1 @@
+['
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/ascii-unicode-identifier/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/ascii-unicode-identifier/error
new file mode 100644
index 000000000..a4d814280
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/ascii-unicode-identifier/error
@@ -0,0 +1,2 @@
+1 1 1
+'[' or '{' expected near 'a'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/ascii-unicode-identifier/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/ascii-unicode-identifier/input
new file mode 100644
index 000000000..c2c0208ed
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/ascii-unicode-identifier/input
@@ -0,0 +1 @@
+aå
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/brace-comma/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/brace-comma/error
new file mode 100644
index 000000000..ce046213c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/brace-comma/error
@@ -0,0 +1,2 @@
+1 2 2
+string or '}' expected near ','
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/brace-comma/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/brace-comma/input
new file mode 100644
index 000000000..74a6628d4
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/brace-comma/input
@@ -0,0 +1 @@
+{,
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-comma/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-comma/error
new file mode 100644
index 000000000..ce0a912bf
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-comma/error
@@ -0,0 +1,2 @@
+1 2 2
+unexpected token near ','
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-comma/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-comma/input
new file mode 100644
index 000000000..5b911f11d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-comma/input
@@ -0,0 +1 @@
+[,
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/error.normal
new file mode 100644
index 000000000..0248b114a
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/error.normal
@@ -0,0 +1,2 @@
+2 0 4
+']' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/error.strip
new file mode 100644
index 000000000..f89b38fcb
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/error.strip
@@ -0,0 +1,2 @@
+1 3 3
+']' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/input
new file mode 100644
index 000000000..874691b1d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/input
@@ -0,0 +1 @@
+[1,
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/empty/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/empty/error
new file mode 100644
index 000000000..f45da6f82
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/empty/error
@@ -0,0 +1,2 @@
+1 0 0
+'[' or '{' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/empty/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/empty/input
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/empty/input
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-array/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-array/error
new file mode 100644
index 000000000..cae86c246
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-array/error
@@ -0,0 +1,2 @@
+1 4 4
+unexpected token near ']'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-array/input
new file mode 100644
index 000000000..e8b1a170f
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-array/input
@@ -0,0 +1 @@
+[1,]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-multiline-array/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-multiline-array/error
new file mode 100644
index 000000000..5baeea447
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-multiline-array/error
@@ -0,0 +1,2 @@
+6 1 17
+unexpected token near ']'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-multiline-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-multiline-array/input
new file mode 100644
index 000000000..bcb2a7526
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-multiline-array/input
@@ -0,0 +1,6 @@
+[1,
+2,
+3,
+4,
+5,
+]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-after-newline/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-after-newline/error
new file mode 100644
index 000000000..5d2dec374
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-after-newline/error
@@ -0,0 +1,2 @@
+2 3 11
+end of file expected near 'foo'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-after-newline/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-after-newline/input
new file mode 100644
index 000000000..3614ac78f
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-after-newline/input
@@ -0,0 +1,2 @@
+[1,2,3]
+foo
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-at-the-end/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-at-the-end/error
new file mode 100644
index 000000000..cdd817572
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-at-the-end/error
@@ -0,0 +1,2 @@
+1 10 10
+end of file expected near 'foo'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-at-the-end/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-at-the-end/input
new file mode 100644
index 000000000..55aee53d2
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-at-the-end/input
@@ -0,0 +1 @@
+[1,2,3]foo
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/integer-starting-with-zero/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/integer-starting-with-zero/error
new file mode 100644
index 000000000..64e0536aa
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/integer-starting-with-zero/error
@@ -0,0 +1,2 @@
+1 2 2
+invalid token near '0'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/integer-starting-with-zero/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/integer-starting-with-zero/input
new file mode 100644
index 000000000..12f67e2c2
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/integer-starting-with-zero/input
@@ -0,0 +1 @@
+[012]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-escape/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-escape/error
new file mode 100644
index 000000000..d9863f73b
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-escape/error
@@ -0,0 +1,2 @@
+1 4 4
+invalid escape near '"\a'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-escape/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-escape/input
new file mode 100644
index 000000000..64c7b70d9
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-escape/input
@@ -0,0 +1 @@
+["\a <-- invalid escape"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-identifier/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-identifier/error
new file mode 100644
index 000000000..496c6aba2
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-identifier/error
@@ -0,0 +1,2 @@
+1 5 5
+invalid token near 'troo'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-identifier/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-identifier/input
new file mode 100644
index 000000000..3d2860da1
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-identifier/input
@@ -0,0 +1 @@
+[troo
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-integer/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-integer/error
new file mode 100644
index 000000000..f2526c51e
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-integer/error
@@ -0,0 +1,2 @@
+1 8 8
+']' expected near 'foo'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-integer/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-integer/input
new file mode 100644
index 000000000..6196980ec
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-integer/input
@@ -0,0 +1 @@
+[-123foo]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-real/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-real/error
new file mode 100644
index 000000000..933158ae5
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-real/error
@@ -0,0 +1,2 @@
+1 12 12
+']' expected near 'foo'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-real/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-real/input
new file mode 100644
index 000000000..3c763d334
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-real/input
@@ -0,0 +1 @@
+[-123.123foo]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-second-surrogate/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-second-surrogate/error
new file mode 100644
index 000000000..e5a2359e6
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-second-surrogate/error
@@ -0,0 +1,2 @@
+1 62 62
+invalid Unicode '\uD888\u3210'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-second-surrogate/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-second-surrogate/input
new file mode 100644
index 000000000..b21453f6f
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-second-surrogate/input
@@ -0,0 +1 @@
+["\uD888\u3210 (first surrogate and invalid second surrogate)"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-unicode-escape/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-unicode-escape/error
new file mode 100644
index 000000000..221c762eb
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-unicode-escape/error
@@ -0,0 +1,2 @@
+1 5 5
+invalid escape near '"\uq'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-unicode-escape/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-unicode-escape/input
new file mode 100644
index 000000000..f381e85b8
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-unicode-escape/input
@@ -0,0 +1 @@
+["\uqqqq <-- invalid unicode escape"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/error.normal
new file mode 100644
index 000000000..00dc765b9
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/error.normal
@@ -0,0 +1,2 @@
+2 0 2
+string or '}' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/error.strip
new file mode 100644
index 000000000..bb1c04745
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/error.strip
@@ -0,0 +1,2 @@
+1 1 1
+string or '}' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/input
new file mode 100644
index 000000000..98232c64f
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/input
@@ -0,0 +1 @@
+{
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/error.normal
new file mode 100644
index 000000000..f463928f8
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/error.normal
@@ -0,0 +1,2 @@
+2 0 2
+']' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/error.strip
new file mode 100644
index 000000000..2bc07ea0c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/error.strip
@@ -0,0 +1,2 @@
+1 1 1
+']' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/input
new file mode 100644
index 000000000..558ed37d9
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/input
@@ -0,0 +1 @@
+[
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-second-surrogate/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-second-surrogate/error
new file mode 100644
index 000000000..bc5f34e11
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-second-surrogate/error
@@ -0,0 +1,2 @@
+1 40 40
+invalid Unicode '\uDFAA'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-second-surrogate/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-second-surrogate/input
new file mode 100644
index 000000000..328e35c82
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-second-surrogate/input
@@ -0,0 +1 @@
+["\uDFAA (second surrogate on it's own)"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/minus-sign-without-number/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/minus-sign-without-number/error
new file mode 100644
index 000000000..b3a78b978
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/minus-sign-without-number/error
@@ -0,0 +1,2 @@
+1 2 2
+invalid token near '-'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/minus-sign-without-number/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/minus-sign-without-number/input
new file mode 100644
index 000000000..033788355
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/minus-sign-without-number/input
@@ -0,0 +1 @@
+[-foo]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/negative-integer-starting-with-zero/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/negative-integer-starting-with-zero/error
new file mode 100644
index 000000000..36adc34b4
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/negative-integer-starting-with-zero/error
@@ -0,0 +1,2 @@
+1 3 3
+invalid token near '-0'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/negative-integer-starting-with-zero/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/negative-integer-starting-with-zero/input
new file mode 100644
index 000000000..6fbb7a2f8
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/negative-integer-starting-with-zero/input
@@ -0,0 +1 @@
+[-012]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-object-key/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-object-key/error
new file mode 100644
index 000000000..3ec685b5d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-object-key/error
@@ -0,0 +1,2 @@
+1 15 15
+NUL byte in object key not supported near '"foo\u0000bar"'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-object-key/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-object-key/input
new file mode 100644
index 000000000..593f0f67f
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-object-key/input
@@ -0,0 +1 @@
+{"foo\u0000bar": 42}
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/error
new file mode 100644
index 000000000..45f9bd817
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/error
@@ -0,0 +1,2 @@
+1 12 12
+control character 0x0 near '"null byte '
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/input
new file mode 100644
index 000000000..268d1f194
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/input
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/nostrip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/nostrip
new file mode 100644
index 000000000..80f4bf761
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/nostrip
@@ -0,0 +1,2 @@
+The embedded NULL byte breaks json_loads(), which is used instead of
+json_loadf() in the stripped tests.
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/error
new file mode 100644
index 000000000..44d4def92
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/error
@@ -0,0 +1,2 @@
+1 2 2
+invalid token near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/input
new file mode 100644
index 000000000..aa550eb0c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/input
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/nostrip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/nostrip
new file mode 100644
index 000000000..80f4bf761
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/nostrip
@@ -0,0 +1,2 @@
+The embedded NULL byte breaks json_loads(), which is used instead of
+json_loadf() in the stripped tests.
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-escape-in-string/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-escape-in-string/error
new file mode 100644
index 000000000..3f5c8c6ca
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-escape-in-string/error
@@ -0,0 +1,2 @@
+1 33 33
+\u0000 is not allowed without JSON_ALLOW_NUL
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-escape-in-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-escape-in-string/input
new file mode 100644
index 000000000..dbc9c9a99
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-escape-in-string/input
@@ -0,0 +1 @@
+["null escape \u0000 not allowed"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null/error
new file mode 100644
index 000000000..1f5d46490
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null/error
@@ -0,0 +1,2 @@
+1 4 4
+'[' or '{' expected near 'null'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null/input
new file mode 100644
index 000000000..19765bd50
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null/input
@@ -0,0 +1 @@
+null
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-apostrophes/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-apostrophes/error
new file mode 100644
index 000000000..23fab01f6
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-apostrophes/error
@@ -0,0 +1,2 @@
+1 2 2
+string or '}' expected near '''
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-apostrophes/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-apostrophes/input
new file mode 100644
index 000000000..52b290574
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-apostrophes/input
@@ -0,0 +1 @@
+{'a'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-garbage-at-end/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-garbage-at-end/error
new file mode 100644
index 000000000..06c4ec1c2
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-garbage-at-end/error
@@ -0,0 +1,2 @@
+1 12 12
+'}' expected near '123'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-garbage-at-end/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-garbage-at-end/input
new file mode 100644
index 000000000..62c19d742
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-garbage-at-end/input
@@ -0,0 +1 @@
+{"a":"a" 123}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/error.normal
new file mode 100644
index 000000000..0248b114a
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/error.normal
@@ -0,0 +1,2 @@
+2 0 4
+']' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/error.strip
new file mode 100644
index 000000000..f89b38fcb
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/error.strip
@@ -0,0 +1,2 @@
+1 3 3
+']' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/input
new file mode 100644
index 000000000..ca9ec378e
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/input
@@ -0,0 +1 @@
+[{}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/error.normal
new file mode 100644
index 000000000..78d84f7b7
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/error.normal
@@ -0,0 +1,2 @@
+2 0 5
+':' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/error.strip
new file mode 100644
index 000000000..528e266d2
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/error.strip
@@ -0,0 +1,2 @@
+1 4 4
+':' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/input
new file mode 100644
index 000000000..107e6265c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/input
@@ -0,0 +1 @@
+{"a"
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/error.normal
new file mode 100644
index 000000000..47ad902dd
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/error.normal
@@ -0,0 +1,2 @@
+2 0 6
+unexpected token near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/error.strip
new file mode 100644
index 000000000..b36c5e2bc
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/error.strip
@@ -0,0 +1,2 @@
+1 5 5
+unexpected token near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/input
new file mode 100644
index 000000000..f68f26269
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/input
@@ -0,0 +1 @@
+{"a":
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/error.normal
new file mode 100644
index 000000000..2ad76d473
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/error.normal
@@ -0,0 +1,2 @@
+1 7 7
+unexpected newline near '"a'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/error.strip
new file mode 100644
index 000000000..385afb534
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/error.strip
@@ -0,0 +1,2 @@
+1 7 7
+premature end of input near '"a'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/input
new file mode 100644
index 000000000..b854d7e18
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/input
@@ -0,0 +1 @@
+{"a":"a
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-garbage-after-e/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-garbage-after-e/error
new file mode 100644
index 000000000..b40ffa9b5
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-garbage-after-e/error
@@ -0,0 +1,2 @@
+1 3 3
+invalid token near '1e'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-garbage-after-e/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-garbage-after-e/input
new file mode 100644
index 000000000..6a945ac0f
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-garbage-after-e/input
@@ -0,0 +1 @@
+[1ea]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-negative-overflow/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-negative-overflow/error
new file mode 100644
index 000000000..d7f8e412d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-negative-overflow/error
@@ -0,0 +1,2 @@
+1 15 15
+real number overflow near '-123123e100000'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-negative-overflow/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-negative-overflow/input
new file mode 100644
index 000000000..b5bd21c46
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-negative-overflow/input
@@ -0,0 +1 @@
+[-123123e100000]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-positive-overflow/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-positive-overflow/error
new file mode 100644
index 000000000..55883c981
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-positive-overflow/error
@@ -0,0 +1,2 @@
+1 14 14
+real number overflow near '123123e100000'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-positive-overflow/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-positive-overflow/input
new file mode 100644
index 000000000..524e53b31
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-positive-overflow/input
@@ -0,0 +1 @@
+[123123e100000]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-e/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-e/error
new file mode 100644
index 000000000..b40ffa9b5
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-e/error
@@ -0,0 +1,2 @@
+1 3 3
+invalid token near '1e'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-e/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-e/input
new file mode 100644
index 000000000..1d67b7b82
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-e/input
@@ -0,0 +1 @@
+[1e]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-point/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-point/error
new file mode 100644
index 000000000..db972e8e1
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-point/error
@@ -0,0 +1,2 @@
+1 3 3
+invalid token near '1.'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-point/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-point/input
new file mode 100644
index 000000000..b652b3fe0
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-point/input
@@ -0,0 +1 @@
+[1.]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/recursion-depth/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/recursion-depth/error
new file mode 100644
index 000000000..11e0537ff
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/recursion-depth/error
@@ -0,0 +1,2 @@
+1 2049 2049
+maximum parsing depth reached near '['
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/recursion-depth/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/recursion-depth/input
new file mode 100644
index 000000000..bfa47d9d1
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/recursion-depth/input
@@ -0,0 +1 @@
+[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/run b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/run
new file mode 100755
index 000000000..d1d490c63
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/run
@@ -0,0 +1,57 @@
+#!/bin/sh
+#
+# Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+#
+# Jansson is free software; you can redistribute it and/or modify
+# it under the terms of the MIT license. See LICENSE for details.
+
+is_test() {
+    test -d $test_path
+}
+
+do_run() {
+    variant=$1
+    s=".$1"
+
+    strip=0
+    if [ "$variant" = "strip" ]; then
+        # This test should not be stripped
+        [ -f $test_path/nostrip ] && return
+        strip=1
+    fi
+
+    STRIP=$strip $json_process --env \
+        <$test_path/input >$test_log/stdout$s 2>$test_log/stderr$s
+    valgrind_check $test_log/stderr$s || return 1
+
+    ref=error
+    [ -f $test_path/error$s ] && ref=error$s
+
+    if ! cmp -s $test_path/$ref $test_log/stderr$s; then
+        echo $variant > $test_log/variant
+        return 1
+    fi
+}
+
+run_test() {
+    do_run normal && do_run strip
+}
+
+show_error() {
+    valgrind_show_error && return
+
+    read variant < $test_log/variant
+    s=".$variant"
+
+    echo "VARIANT: $variant"
+
+    echo "EXPECTED ERROR:"
+    ref=error
+    [ -f $test_path/error$s ] && ref=error$s
+    nl -bn $test_path/$ref
+
+    echo "ACTUAL ERROR:"
+    nl -bn $test_log/stderr$s
+}
+
+. $top_srcdir/test/scripts/run-tests.sh
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/tab-character-in-string/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/tab-character-in-string/error
new file mode 100644
index 000000000..9e2f76ed2
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/tab-character-in-string/error
@@ -0,0 +1,2 @@
+1 2 2
+control character 0x9 near '"'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/tab-character-in-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/tab-character-in-string/input
new file mode 100644
index 000000000..3ebae0953
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/tab-character-in-string/input
@@ -0,0 +1 @@
+["	 <-- tab character"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-negative-integer/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-negative-integer/error
new file mode 100644
index 000000000..a0640b9a9
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-negative-integer/error
@@ -0,0 +1,2 @@
+1 32 32
+too big negative integer
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-negative-integer/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-negative-integer/input
new file mode 100644
index 000000000..d6c26f1cf
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-negative-integer/input
@@ -0,0 +1 @@
+[-123123123123123123123123123123]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-positive-integer/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-positive-integer/error
new file mode 100644
index 000000000..3bdbefd53
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-positive-integer/error
@@ -0,0 +1,2 @@
+1 31 31
+too big integer
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-positive-integer/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-positive-integer/input
new file mode 100644
index 000000000..27c855399
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-positive-integer/input
@@ -0,0 +1 @@
+[123123123123123123123123123123]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/truncated-unicode-surrogate/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/truncated-unicode-surrogate/error
new file mode 100644
index 000000000..1b99f061a
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/truncated-unicode-surrogate/error
@@ -0,0 +1,2 @@
+1 46 46
+invalid Unicode '\uDADA'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/truncated-unicode-surrogate/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/truncated-unicode-surrogate/input
new file mode 100644
index 000000000..2b340f4ad
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/truncated-unicode-surrogate/input
@@ -0,0 +1 @@
+["\uDADA (first surrogate without the second)"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unicode-identifier/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unicode-identifier/error
new file mode 100644
index 000000000..178b0dd4d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unicode-identifier/error
@@ -0,0 +1,2 @@
+1 1 2
+'[' or '{' expected near 'å'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unicode-identifier/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unicode-identifier/input
new file mode 100644
index 000000000..aad321caf
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unicode-identifier/input
@@ -0,0 +1 @@
+å
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/error.normal
new file mode 100644
index 000000000..5b19804bc
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/error.normal
@@ -0,0 +1,2 @@
+2 0 3
+string or '}' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/error.strip
new file mode 100644
index 000000000..da2bb22f1
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/error.strip
@@ -0,0 +1,2 @@
+1 2 2
+string or '}' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/input
new file mode 100644
index 000000000..cd9dc6482
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/input
@@ -0,0 +1 @@
+[{
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/error.normal
new file mode 100644
index 000000000..8025ed1b0
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/error.normal
@@ -0,0 +1,2 @@
+2 0 5
+']' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/error.strip
new file mode 100644
index 000000000..495d0f7c4
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/error.strip
@@ -0,0 +1,2 @@
+1 4 4
+']' expected near end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/input
new file mode 100644
index 000000000..727ee8106
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/input
@@ -0,0 +1 @@
+["a"
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/error.normal
new file mode 100644
index 000000000..3d646abda
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/error.normal
@@ -0,0 +1,2 @@
+1 2 2
+unexpected newline near '"'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/error.strip
new file mode 100644
index 000000000..94f194715
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/error.strip
@@ -0,0 +1,2 @@
+1 2 2
+premature end of input near '"'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/input
new file mode 100644
index 000000000..4117452de
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/input
@@ -0,0 +1 @@
+{"
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/error.normal
new file mode 100644
index 000000000..5f09b77da
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/error.normal
@@ -0,0 +1,2 @@
+1 3 3
+unexpected newline near '"a'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/error.strip
new file mode 100644
index 000000000..8b6bec430
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/error.strip
@@ -0,0 +1,2 @@
+1 3 3
+premature end of input near '"a'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/input
new file mode 100644
index 000000000..705948c64
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/input
@@ -0,0 +1 @@
+{"a
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-object-and-array/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-object-and-array/error
new file mode 100644
index 000000000..ed97be73e
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-object-and-array/error
@@ -0,0 +1,2 @@
+1 2 2
+string or '}' expected near '['
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-object-and-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-object-and-array/input
new file mode 100644
index 000000000..da35a8620
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-object-and-array/input
@@ -0,0 +1 @@
+{[
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/error.normal
new file mode 100644
index 000000000..5f09b77da
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/error.normal
@@ -0,0 +1,2 @@
+1 3 3
+unexpected newline near '"a'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/error.strip
new file mode 100644
index 000000000..8b6bec430
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/error.strip
@@ -0,0 +1,2 @@
+1 3 3
+premature end of input near '"a'
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/input
new file mode 100644
index 000000000..38ab6b04c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/input
@@ -0,0 +1 @@
+["a
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/env
new file mode 100644
index 000000000..bd89eff9d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/env
@@ -0,0 +1 @@
+JSON_SORT_KEYS=1
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/input
new file mode 100644
index 000000000..1b9bbb949
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/input
@@ -0,0 +1,5 @@
+[1,2,3,4,
+"a", "b", "c",
+{"foo": "bar", "core": "dump"},
+true, false, true, true, null, false
+]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/output
new file mode 100644
index 000000000..7aefe5642
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/output
@@ -0,0 +1 @@
+[1, 2, 3, 4, "a", "b", "c", {"core": "dump", "foo": "bar"}, true, false, true, true, null, false]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-array/input
new file mode 100644
index 000000000..fe51488c7
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-array/input
@@ -0,0 +1 @@
+[]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-array/output
new file mode 100644
index 000000000..0637a088a
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-array/output
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object-in-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object-in-array/input
new file mode 100644
index 000000000..93d51406d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object-in-array/input
@@ -0,0 +1 @@
+[{}]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object-in-array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object-in-array/output
new file mode 100644
index 000000000..ee1aac42b
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object-in-array/output
@@ -0,0 +1 @@
+[{}]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object/input
new file mode 100644
index 000000000..0967ef424
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object/input
@@ -0,0 +1 @@
+{}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object/output
new file mode 100644
index 000000000..9e26dfeeb
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object/output
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-string/input
new file mode 100644
index 000000000..66a1e1856
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-string/input
@@ -0,0 +1 @@
+[""]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-string/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-string/output
new file mode 100644
index 000000000..93b6be2bc
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-string/output
@@ -0,0 +1 @@
+[""]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/escaped-utf-control-char/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/escaped-utf-control-char/input
new file mode 100644
index 000000000..9a98545c0
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/escaped-utf-control-char/input
@@ -0,0 +1 @@
+["\u0012 escaped control character"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/escaped-utf-control-char/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/escaped-utf-control-char/output
new file mode 100644
index 000000000..07221b78d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/escaped-utf-control-char/output
@@ -0,0 +1 @@
+["\u0012 escaped control character"]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/false/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/false/input
new file mode 100644
index 000000000..434365202
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/false/input
@@ -0,0 +1 @@
+[false]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/false/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/false/output
new file mode 100644
index 000000000..67b2f0760
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/false/output
@@ -0,0 +1 @@
+[false]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-int/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-int/input
new file mode 100644
index 000000000..a96d5cdb3
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-int/input
@@ -0,0 +1 @@
+[-123]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-int/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-int/output
new file mode 100644
index 000000000..8e30f8bd9
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-int/output
@@ -0,0 +1 @@
+[-123]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-one/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-one/input
new file mode 100644
index 000000000..2363a1ac0
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-one/input
@@ -0,0 +1 @@
+[-1]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-one/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-one/output
new file mode 100644
index 000000000..99d21a2a0
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-one/output
@@ -0,0 +1 @@
+[-1]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-zero/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-zero/input
new file mode 100644
index 000000000..40fc49c71
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-zero/input
@@ -0,0 +1 @@
+[-0]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-zero/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-zero/output
new file mode 100644
index 000000000..6e7ea636e
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-zero/output
@@ -0,0 +1 @@
+[0]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/null/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/null/input
new file mode 100644
index 000000000..62864b313
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/null/input
@@ -0,0 +1 @@
+[null]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/null/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/null/output
new file mode 100644
index 000000000..500db4a86
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/null/output
@@ -0,0 +1 @@
+[null]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/one-byte-utf-8/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/one-byte-utf-8/input
new file mode 100644
index 000000000..8bda4685d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/one-byte-utf-8/input
@@ -0,0 +1 @@
+["\u002c one-byte UTF-8"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/one-byte-utf-8/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/one-byte-utf-8/output
new file mode 100644
index 000000000..c33d250ff
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/one-byte-utf-8/output
@@ -0,0 +1 @@
+[", one-byte UTF-8"]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-negative-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-negative-exponent/input
new file mode 100644
index 000000000..1e9fa5153
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-negative-exponent/input
@@ -0,0 +1 @@
+[1E-2]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-negative-exponent/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-negative-exponent/output
new file mode 100644
index 000000000..75b9ef92c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-negative-exponent/output
@@ -0,0 +1 @@
+[0.01]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-positive-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-positive-exponent/input
new file mode 100644
index 000000000..6a6ab9337
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-positive-exponent/input
@@ -0,0 +1 @@
+[1E+2]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-positive-exponent/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-positive-exponent/output
new file mode 100644
index 000000000..d8ff702a1
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-positive-exponent/output
@@ -0,0 +1 @@
+[100.0]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e/input
new file mode 100644
index 000000000..e70322356
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e/input
@@ -0,0 +1 @@
+[1E22]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e/output
new file mode 100644
index 000000000..9a739f21f
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e/output
@@ -0,0 +1 @@
+[1e22]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-exponent/input
new file mode 100644
index 000000000..b2a69b9a3
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-exponent/input
@@ -0,0 +1 @@
+[123e45]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-exponent/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-exponent/output
new file mode 100644
index 000000000..5ffc7196d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-exponent/output
@@ -0,0 +1 @@
+[1.2299999999999999e47]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-fraction-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-fraction-exponent/input
new file mode 100644
index 000000000..0c1660d1e
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-fraction-exponent/input
@@ -0,0 +1 @@
+[123.456e78]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-fraction-exponent/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-fraction-exponent/output
new file mode 100644
index 000000000..66a3c8186
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-fraction-exponent/output
@@ -0,0 +1 @@
+[1.23456e80]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-negative-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-negative-exponent/input
new file mode 100644
index 000000000..daa4af932
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-negative-exponent/input
@@ -0,0 +1 @@
+[1e-2]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-negative-exponent/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-negative-exponent/output
new file mode 100644
index 000000000..75b9ef92c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-negative-exponent/output
@@ -0,0 +1 @@
+[0.01]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-positive-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-positive-exponent/input
new file mode 100644
index 000000000..f3780773a
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-positive-exponent/input
@@ -0,0 +1 @@
+[1e+2]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-positive-exponent/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-positive-exponent/output
new file mode 100644
index 000000000..d8ff702a1
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-positive-exponent/output
@@ -0,0 +1 @@
+[100.0]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-subnormal-number/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-subnormal-number/input
new file mode 100644
index 000000000..df6065345
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-subnormal-number/input
@@ -0,0 +1 @@
+[1.8011670033376514e-308]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-subnormal-number/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-subnormal-number/output
new file mode 100644
index 000000000..e6b0a58e8
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-subnormal-number/output
@@ -0,0 +1 @@
+[1.8011670033376514e-308]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-underflow/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-underflow/input
new file mode 100644
index 000000000..dc709960a
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-underflow/input
@@ -0,0 +1 @@
+[123e-10000000]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-underflow/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-underflow/output
new file mode 100644
index 000000000..92df1df1d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-underflow/output
@@ -0,0 +1 @@
+[0.0]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/run b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/run
new file mode 100755
index 000000000..d99548960
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/run
@@ -0,0 +1,56 @@
+#!/bin/sh
+#
+# Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+#
+# Jansson is free software; you can redistribute it and/or modify
+# it under the terms of the MIT license. See LICENSE for details.
+
+JSON_SORT_KEYS=1
+export JSON_SORT_KEYS
+
+is_test() {
+    test -d $test_path
+}
+
+do_run() {
+    variant=$1
+    s=".$1"
+
+    strip=0
+    [ "$variant" = "strip" ] && strip=1
+
+    STRIP=$strip $json_process --env \
+        <$test_path/input >$test_log/stdout$s 2>$test_log/stderr$s
+    valgrind_check $test_log/stderr$s || return 1
+
+    ref=output
+    [ -f $test_path/output$s ] && ref=output$s
+
+    if ! cmp -s $test_path/$ref $test_log/stdout$s; then
+        echo $variant > $test_log/variant
+        return 1
+    fi
+}
+
+run_test() {
+    do_run normal && do_run strip
+}
+
+show_error() {
+    valgrind_show_error && return
+
+    read variant < $test_log/variant
+    s=".$variant"
+
+    echo "VARIANT: $variant"
+
+    echo "EXPECTED OUTPUT:"
+    ref=output
+    [ -f $test_path/output$s ] && ref=output$s
+    nl -bn $test_path/$ref
+
+    echo "ACTUAL OUTPUT:"
+    nl -bn $test_log/stdout$s
+}
+
+. $top_srcdir/test/scripts/run-tests.sh
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/short-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/short-string/input
new file mode 100644
index 000000000..0c3426d4c
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/short-string/input
@@ -0,0 +1 @@
+["a"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/short-string/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/short-string/output
new file mode 100644
index 000000000..eac5f7b46
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/short-string/output
@@ -0,0 +1 @@
+["a"]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-ascii-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-ascii-string/input
new file mode 100644
index 000000000..929b215c1
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-ascii-string/input
@@ -0,0 +1 @@
+["abcdefghijklmnopqrstuvwxyz1234567890 "]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-ascii-string/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-ascii-string/output
new file mode 100644
index 000000000..90358ab70
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-ascii-string/output
@@ -0,0 +1 @@
+["abcdefghijklmnopqrstuvwxyz1234567890 "]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-0/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-0/input
new file mode 100644
index 000000000..111bb8686
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-0/input
@@ -0,0 +1 @@
+[0]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-0/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-0/output
new file mode 100644
index 000000000..6e7ea636e
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-0/output
@@ -0,0 +1 @@
+[0]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-1/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-1/input
new file mode 100644
index 000000000..7660873d1
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-1/input
@@ -0,0 +1 @@
+[1]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-1/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-1/output
new file mode 100644
index 000000000..bace2a0be
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-1/output
@@ -0,0 +1 @@
+[1]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-123/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-123/input
new file mode 100644
index 000000000..3214bfe58
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-123/input
@@ -0,0 +1 @@
+[123]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-123/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-123/output
new file mode 100644
index 000000000..e47f69afc
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-123/output
@@ -0,0 +1 @@
+[123]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-object/input
new file mode 100644
index 000000000..a34fb4907
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-object/input
@@ -0,0 +1 @@
+{"a":[]}
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-object/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-object/output
new file mode 100644
index 000000000..982abe826
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-object/output
@@ -0,0 +1 @@
+{"a": []}
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-real/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-real/input
new file mode 100644
index 000000000..0fed7df36
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-real/input
@@ -0,0 +1 @@
+[123.456789]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-real/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-real/output
new file mode 100644
index 000000000..b02878e5f
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-real/output
@@ -0,0 +1 @@
+[123.456789]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/string-escapes/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/string-escapes/input
new file mode 100644
index 000000000..d994564d3
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/string-escapes/input
@@ -0,0 +1 @@
+["\"\\\/\b\f\n\r\t"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/string-escapes/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/string-escapes/output
new file mode 100644
index 000000000..ca5c1c658
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/string-escapes/output
@@ -0,0 +1 @@
+["\"\\/\b\f\n\r\t"]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/three-byte-utf-8/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/three-byte-utf-8/input
new file mode 100644
index 000000000..ccc0bfa57
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/three-byte-utf-8/input
@@ -0,0 +1 @@
+["\u0821 three-byte UTF-8"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/three-byte-utf-8/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/three-byte-utf-8/output
new file mode 100644
index 000000000..c44d124e7
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/three-byte-utf-8/output
@@ -0,0 +1 @@
+["ࠡ three-byte UTF-8"]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/true/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/true/input
new file mode 100644
index 000000000..29513c491
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/true/input
@@ -0,0 +1 @@
+[true]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/true/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/true/output
new file mode 100644
index 000000000..de601e305
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/true/output
@@ -0,0 +1 @@
+[true]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/two-byte-utf-8/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/two-byte-utf-8/input
new file mode 100644
index 000000000..05ae854b5
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/two-byte-utf-8/input
@@ -0,0 +1 @@
+["\u0123 two-byte UTF-8"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/two-byte-utf-8/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/two-byte-utf-8/output
new file mode 100644
index 000000000..1f0988d94
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/two-byte-utf-8/output
@@ -0,0 +1 @@
+["ģ two-byte UTF-8"]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-8-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-8-string/input
new file mode 100644
index 000000000..20dc64a45
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-8-string/input
@@ -0,0 +1 @@
+["€þıœəßð some utf-8 ĸʒ×ŋµåäö𝄞"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-8-string/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-8-string/output
new file mode 100644
index 000000000..53728650d
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-8-string/output
@@ -0,0 +1 @@
+["€þıœəßð some utf-8 ĸʒ×ŋµåäö𝄞"]
\ No newline at end of file
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-surrogate-four-byte-encoding/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-surrogate-four-byte-encoding/input
new file mode 100644
index 000000000..c598b4172
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-surrogate-four-byte-encoding/input
@@ -0,0 +1 @@
+["\uD834\uDD1E surrogate, four-byte UTF-8"]
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-surrogate-four-byte-encoding/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-surrogate-four-byte-encoding/output
new file mode 100644
index 000000000..fa806d254
--- /dev/null
+++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-surrogate-four-byte-encoding/output
@@ -0,0 +1 @@
+["𝄞 surrogate, four-byte UTF-8"]
\ No newline at end of file