Yaroslav Stavnichiy avatar Yaroslav Stavnichiy committed f87030e

Rewritten some things. Fixed bugs. Added test suite.

Comments (0)

Files changed (79)

 ^nxjson$
+^tests/.*\.result$
 
 all: nxjson
 
-nxjson: nxjson.c
-	gcc -O0 -g -DDEBUG ${CFLAGS} nxjson.c -o nxjson
+nxjson: nxjson.c test.c nxjson.h
+	gcc -O0 -g -Wall ${CFLAGS} nxjson.c test.c -o nxjson
 
 clean:
 	rm nxjson
 
 ##Features
 
-- Parse JSON from string
-- Easy browsing API
+- Parse JSON from null-terminated string
+- Easy to use tree traversal API
 - Unescape string values (except Unicode)
 - Comments // line and /\* block \*/ skipped
+- Test suite included
 
 ##Limitations
 
 - No Unicode support (\uXXXX escape sequences remain untouched)
-- Might accept invalid JSON (eg., extra commas, comments), don't use for validation
+- Might accept invalid JSON (eg., extra or missing commas, comments), not suitable for validation
 
 ##Example
 
  * License along with NXJSON. If not, see <http://www.gnu.org/licenses/>.
  */
 
+// this file can be #included in your code
+#ifndef NXJSON_C
+#define NXJSON_C
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <malloc.h>
+#include <assert.h>
 
 #include "nxjson.h"
 
+// redefine NX_JSON_CALLOC & NX_JSON_FREE to use custom allocator
+#ifndef NX_JSON_CALLOC
+#define NX_JSON_CALLOC() calloc(1, sizeof(nx_json))
+#define NX_JSON_FREE(json) free((void*)(json))
+#endif
+
+// redefine NX_JSON_REPORT_ERROR to use custom error reporting
+#ifndef NX_JSON_REPORT_ERROR
+#define NX_JSON_REPORT_ERROR(msg, p) fprintf(stderr, "NXJSON PARSE ERROR (%d): " msg " at %s\n", __LINE__, p)
+#endif
+
+#define IS_WHITESPACE(c) ((unsigned char)(c)<=(unsigned char)' ')
+
 static const nx_json dummy={ NX_JSON_NULL };
 
-static void append_json(nx_json* parent, nx_json* child) {
-  nx_json* p=parent->child;
-  if (!p) {
-    parent->child=child;
+static nx_json* create_json(nx_json_type type, const char* key, nx_json* parent) {
+  nx_json* js=NX_JSON_CALLOC();
+  assert(js);
+  js->type=type;
+  js->key=key;
+  if (!parent->last_child) {
+    parent->child=parent->last_child=js;
   }
   else {
-    while (p->next) p=p->next;
-    p->next=child;
+    parent->last_child->next=js;
+    parent->last_child=js;
   }
   parent->length++;
-}
-
-static nx_json* create_json(nx_json_type type, const char* tag, nx_json* parent) {
-  nx_json* js=calloc(1, sizeof(nx_json));
-  js->type=type;
-  js->tag=tag;
-  append_json(parent, js);
   return js;
 }
 
     nx_json_free(p);
     p=p1;
   }
-  free((void*)js);
+  NX_JSON_FREE(js);
 }
 
-static char* unescape(char* s) {
-  char* p;
-  while (p=strchr(s, '\\')) {
-    switch (p[1]) {
-      // case '\\':
-      // case '"':
-      //   break;
-      case 'b':
-        *p='\b';
-        break;
-      case 'f':
-        *p='\f';
-        break;
-      case 'n':
-        *p='\n';
-        break;
-      case 'r':
-        *p='\r';
-        break;
-      case 't':
-        *p='\t';
-        break;
-      case 'u': // unicode unescape not implemented
-        continue;
+static char* unescape_string(char* s, char** end) {
+  char* p=s;
+  char* d=s;
+  char c;
+  while ((c=*p++)) {
+    if (c=='"') {
+      *d='\0';
+      *end=p;
+      return s;
     }
-    memmove(p, p+1, strlen(p)); // including null-terminator
+    else if (c=='\\') {
+      switch (*p) {
+        case '\\':
+        case '/':
+        case '"':
+          c=*p++;
+          break;
+        case 'b':
+          c='\b'; p++;
+          break;
+        case 'f':
+          c='\f'; p++;
+          break;
+        case 'n':
+          c='\n'; p++;
+          break;
+        case 'r':
+          c='\r'; p++;
+          break;
+        case 't':
+          c='\t'; p++;
+          break;
+        case 'u': // unicode unescape not implemented
+          break;
+      }
+      *d++=c;
+    }
+    else {
+      *d++=c;
+    }
   }
-  return s;
+  NX_JSON_REPORT_ERROR("no closing quote for string", s);
+  return 0;
 }
 
-static char* parse_tag(const char** tag, char* p) {
+static char* parse_key(const char** key, char* p) {
   // on '}' return with *p=='}'
   char c;
-  while (c=*p++) {
+  while ((c=*p++)) {
     if (c=='"') {
-      char* ps=p;
-      REPEAT:
-      p=strchr(p, '"');
-      if (!p) {
-        printf("ERROR: no closing quote for key %s\n", ps);
-        return 0; // error
-      }
-      if (p[-1]=='\\') { // escaped
-        p++;
-        goto REPEAT;
-      }
-      *p++='\0';
-      *tag=ps;
-      while (*p && ((unsigned char)*p)<=' ') p++;
-      return *p==':'? p+1 : 0;
+      *key=unescape_string(p, &p);
+      if (!*key) return 0; // propagate error
+      while (*p && IS_WHITESPACE(*p)) p++;
+      if (*p==':') return p+1;
+      NX_JSON_REPORT_ERROR("unexpected chars", p);
+      return 0;
     }
-    else if (((unsigned char)c)<=' ' || c==',') {
+    else if (IS_WHITESPACE(c) || c==',') {
       // continue
     }
     else if (c=='}') {
         char* ps=p-1;
         p=strchr(p+1, '\n');
         if (!p) {
-          printf("ERROR: endless comment %s\n", ps);
+          NX_JSON_REPORT_ERROR("endless comment", ps);
           return 0; // error
         }
         p++;
         REPEAT2:
         p=strchr(p+1, '/');
         if (!p) {
-          printf("ERROR: endless comment %s\n", ps);
+          NX_JSON_REPORT_ERROR("endless comment", ps);
           return 0; // error
         }
         if (p[-1]!='*') {
         p++;
       }
       else {
-        printf("ERROR (%d) AT: %s\n", __LINE__, p);
+        NX_JSON_REPORT_ERROR("unexpected chars", p-1);
         return 0; // error
       }
     }
     else {
-      printf("ERROR (%d) AT: %s\n", __LINE__, p);
+      NX_JSON_REPORT_ERROR("unexpected chars", p-1);
       return 0; // error
     }
   }
-  printf("ERROR (%d) AT: %s\n", __LINE__, p);
+  NX_JSON_REPORT_ERROR("unexpected chars", p-1);
   return 0; // error
 }
 
-static char* parse_value(nx_json* parent, const char* tag, char* p) {
+static char* parse_value(nx_json* parent, const char* key, char* p) {
   nx_json* js;
   while (1) {
     switch (*p) {
       case '\0':
-        printf("ERROR (%d): unexpected end of text\n", __LINE__);
+        NX_JSON_REPORT_ERROR("unexpected end of text", p);
         return 0; // error
       case ' ': case '\t': case '\n': case '\r':
       case ',':
         p++;
         break;
       case '{':
-        js=create_json(NX_JSON_OBJECT, tag, parent);
+        js=create_json(NX_JSON_OBJECT, key, parent);
         p++;
         while (1) {
-          const char* new_tag;
-          p=parse_tag(&new_tag, p);
+          const char* new_key;
+          p=parse_key(&new_key, p);
           if (!p) return 0; // error
           if (*p=='}') return p+1; // end of object
-          p=parse_value(js, new_tag, p);
+          p=parse_value(js, new_key, p);
           if (!p) return 0; // error
         }
       case '[':
-        js=create_json(NX_JSON_ARRAY, tag, parent);
+        js=create_json(NX_JSON_ARRAY, key, parent);
         p++;
         while (1) {
           p=parse_value(js, 0, p);
         return p;
       case '"':
         p++;
-        char* ps=p;
-        REPEAT:
-        p=strchr(p, '"');
-        if (!p) {
-          printf("ERROR: no closing quote for string %s\n", ps);
-          return 0; // error
-        }
-        if (p[-1]=='\\') { // escaped
-          p++;
-          goto REPEAT;
-        }
-        *p++='\0';
-        js=create_json(NX_JSON_STRING, tag, parent);
-        js->text_value=unescape(ps);
+        js=create_json(NX_JSON_STRING, key, parent);
+        js->text_value=unescape_string(p, &p);
+        if (!js->text_value) return 0; // propagate error
         return p;
       case '-': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
         {
-          js=create_json(NX_JSON_INTEGER, tag, parent);
+          js=create_json(NX_JSON_INTEGER, key, parent);
           char* pe;
           js->int_value=strtol(p, &pe, 0);
           if (pe==p) {
-            printf("ERROR (%d): invalid number AT: %s\n", __LINE__, p);
+            NX_JSON_REPORT_ERROR("invalid number", p);
             return 0; // error
           }
           if (*pe=='.' || *pe=='e' || *pe=='E') { // double value
             js->type=NX_JSON_DOUBLE;
             js->dbl_value=strtod(p, &pe);
             if (pe==p) {
-              printf("ERROR (%d): invalid number AT: %s\n", __LINE__, p);
+              NX_JSON_REPORT_ERROR("invalid number", p);
               return 0; // error
             }
           }
         }
       case 't':
         if (!strncmp(p, "true", 4)) {
-          js=create_json(NX_JSON_BOOL, tag, parent);
+          js=create_json(NX_JSON_BOOL, key, parent);
           js->int_value=1;
           return p+4;
         }
-        printf("ERROR (%d) AT: %s\n", __LINE__, p);
+        NX_JSON_REPORT_ERROR("unexpected chars", p);
         return 0; // error
       case 'f':
         if (!strncmp(p, "false", 5)) {
-          js=create_json(NX_JSON_BOOL, tag, parent);
+          js=create_json(NX_JSON_BOOL, key, parent);
           js->int_value=0;
           return p+5;
         }
-        printf("ERROR (%d) AT: %s\n", __LINE__, p);
+        NX_JSON_REPORT_ERROR("unexpected chars", p);
         return 0; // error
       case 'n':
         if (!strncmp(p, "null", 4)) {
-          create_json(NX_JSON_NULL, tag, parent);
+          create_json(NX_JSON_NULL, key, parent);
           return p+4;
         }
-        printf("ERROR (%d) AT: %s\n", __LINE__, p);
+        NX_JSON_REPORT_ERROR("unexpected chars", p);
         return 0; // error
       case '/': // comment
         if (p[1]=='/') { // line comment
           char* ps=p;
           p=strchr(p+2, '\n');
           if (!p) {
-            printf("ERROR: endless comment %s\n", ps);
+            NX_JSON_REPORT_ERROR("endless comment", ps);
             return 0; // error
           }
           p++;
           REPEAT2:
           p=strchr(p+2, '/');
           if (!p) {
-            printf("ERROR: endless comment %s\n", ps);
+            NX_JSON_REPORT_ERROR("endless comment", ps);
             return 0; // error
           }
           if (p[-1]!='*') {
           p++;
         }
         else {
-          printf("ERROR (%d) AT: %s\n", __LINE__, p);
+          NX_JSON_REPORT_ERROR("unexpected chars", p);
           return 0; // error
         }
         break;
       default:
-        printf("ERROR (%d) AT: %s\n", __LINE__, p);
+        NX_JSON_REPORT_ERROR("unexpected chars", p);
         return 0; // error
     }
   }
   return js.child;
 }
 
-const nx_json* nx_json_get(const nx_json* json, const char* tag) {
-  if (!json) return &dummy;
+const nx_json* nx_json_get(const nx_json* json, const char* key) {
+  if (!json) return &dummy; // never return null
   nx_json* js;
   for (js=json->child; js; js=js->next) {
-    if (!strcmp(js->tag, tag)) return js;
+    if (!strcmp(js->key, key)) return js;
   }
-  return &dummy;
+  return &dummy; // never return null
 }
 
 const nx_json* nx_json_item(const nx_json* json, int idx) {
-  if (!json) return &dummy;
+  if (!json) return &dummy; // never return null
   nx_json* js;
   for (js=json->child; js; js=js->next) {
     if (!idx--) return js;
   }
-  return &dummy;
+  return &dummy; // never return null
 }
 
-#ifdef DEBUG
+#ifdef NXJSON_DEMO
 
 int main() {
-  char* code=strdup(" {\"some-int\":195, \"array\" :[ 0, 5.1, -7, \"nine\" ,, /*11*/ , ],"
-    "\"some-bool\":true, \"some-dbl\":-1e-4, \"some-null\": null, \"hello\" : \"world\\\"!\", /*\"other\" : \"/OTHER/\"*/,\n"
+  char* code=strdup(" {\"some-int\":195, \"array\" :[ 0, 5.1, -7, \"\\\\\" ,, /*11*/ , \"last\\nitem\"],"
+    "\"some-bool\":true, \"some-dbl\":-1e-4, \"some-null\": null, \"hello\" : \"world\\\"\\!\", /*\"other\" : \"/OTHER/\"*/,\n"
     "\"obj\":{\"KEY\":\"VAL\"}\n"
     "}");
   const nx_json* json=nx_json_parse(code);
 }
 
 #endif
+
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif  /* NXJSON_C */
 
 typedef struct nx_json {
   nx_json_type type;
-  const char* tag;
+  const char* key;
   const char* text_value;
   long int_value; // also bool
   double dbl_value;
   int length; // num children
   struct nx_json* child;
   struct nx_json* next;
+  struct nx_json* last_child;
 } nx_json;
 
 const nx_json* nx_json_parse(char* text);
 void nx_json_free(const nx_json* js);
-const nx_json* nx_json_get(const nx_json* json, const char* tag); // get object's property by key
+const nx_json* nx_json_get(const nx_json* json, const char* key); // get object's property by key
 const nx_json* nx_json_item(const nx_json* json, int idx); // get array element by index
 
 
+/*
+ * Copyright (c) 2013 Yaroslav Stavnichiy <yarosla@gmail.com>
+ *
+ * This file is part of NXJSON.
+ *
+ * NXJSON is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * NXJSON is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with NXJSON. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <malloc.h>
+#include <assert.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "nxjson.h"
+
+#define ERROR(msg, p) fprintf(stderr, "ERROR: " msg " %s\n", (p));
+
+static char* load_file(const char* filepath) {
+  struct stat st;
+  if (stat(filepath, &st)==-1) {
+    // ERROR("can't find file", filepath);
+    return 0;
+  }
+  int fd=open(filepath, O_RDONLY);
+  if (fd==-1) {
+    ERROR("can't open file", filepath);
+    return 0;
+  }
+  char* text=malloc(st.st_size+1); // this is not going to be freed
+  if (st.st_size!=read(fd, text, st.st_size)) {
+    ERROR("can't read file", filepath);
+    close(fd);
+    return 0;
+  }
+  close(fd);
+  text[st.st_size]='\0';
+  return text;
+}
+
+static int save_file(const char* filepath, const char* text) {
+  int fd=open(filepath, O_WRONLY|O_CREAT|O_TRUNC, 0644);
+  if (fd==-1) {
+    ERROR("can't open file", filepath);
+    return -1;
+  }
+  int length=strlen(text);
+  if (length!=write(fd, text, length)) {
+    ERROR("can't write file", filepath);
+    close(fd);
+    return -1;
+  }
+  close(fd);
+  return 0;
+}
+
+static void dump(const nx_json* json, char* out, char** end, int indent) {
+  if (!json) {
+    *end=out;
+    return;
+  }
+  int i;
+  for (i=0; i<indent; i++) *out++=' ';
+  if (json->key) {
+    strcpy(out, json->key);
+    out+=strlen(json->key);
+    *out++=':';
+  }
+  switch (json->type) {
+    case NX_JSON_NULL:
+      strcpy(out, "null");
+      out+=4;
+      break;
+    case NX_JSON_OBJECT:
+      *out++='{';
+      *out++='\n';
+      {
+        nx_json* js=json->child;
+        for (js=json->child; js; js=js->next) {
+          dump(js, out, &out, indent+2);
+        }
+      }
+      for (i=0; i<indent; i++) *out++=' ';
+      *out++='}';
+      break;
+    case NX_JSON_ARRAY:
+      *out++='[';
+      *out++='\n';
+      {
+        nx_json* js=json->child;
+        for (js=json->child; js; js=js->next) {
+          dump(js, out, &out, indent+2);
+        }
+      }
+      for (i=0; i<indent; i++) *out++=' ';
+      *out++=']';
+      break;
+    case NX_JSON_STRING:
+      *out++='"';
+      strcpy(out, json->text_value);
+      out+=strlen(json->text_value);
+      *out++='"';
+      break;
+    case NX_JSON_INTEGER:
+      out+=sprintf(out, "%ld", json->int_value);
+      break;
+    case NX_JSON_DOUBLE:
+      out+=sprintf(out, "%le", json->dbl_value);
+      break;
+    case NX_JSON_BOOL:
+      *out++=json->int_value?'T':'F';
+      break;
+    default:
+      strcpy(out, "????");
+      out+=4;
+      break;
+  }
+  *out++='\n';
+  *end=out;
+}
+
+static int run_test(int test_number, char* input, const char* expected_output) {
+  int input_length=strlen(input);
+  const nx_json* json=nx_json_parse(input);
+  if (!json) {
+    if (!expected_output) {
+      printf("[%03d] PASSED\n", test_number);
+      return 1;
+    }
+    else {
+      printf("[%03d] FAILED\n", test_number);
+      return 0;
+    }
+  }
+  char* buf=malloc(input_length*32+4000000); // hope this will be large enough; depends on nesting & indenting
+  char* p=buf;
+  dump(json, p, &p, 0);
+  nx_json_free(json);
+  *p='\0';
+
+  char fname[32];
+  sprintf(fname, "tests/%03d.result", test_number);
+  save_file(fname, buf);
+
+  if (!expected_output) {
+    printf("[%03d] FAILED\n", test_number);
+    free(buf);
+    return 0;
+  }
+  if (!strcmp(buf, expected_output)) {
+    printf("[%03d] PASSED\n", test_number);
+    free(buf);
+    return 1;
+  }
+  else {
+    printf("[%03d] FAILED\n", test_number);
+    free(buf);
+    return 0;
+  }
+}
+
+static void run_tests() {
+  char infile[32];
+  char expfile[32];
+  int i, total=0, passed=0;
+  for (i=1; i<100; i++) {
+    sprintf(infile, "tests/%03d.json", i);
+    sprintf(expfile, "tests/%03d.expected", i);
+    char* input=load_file(infile);
+    if (!input) break;
+    char* expected_output=load_file(expfile);
+    passed+=run_test(i, input, expected_output);
+    total++;
+    free(input);
+    if (expected_output) free(expected_output);
+  }
+  printf("\nPASSED %d OUT OF %d\n", passed, total);
+}
+
+int main() {
+  run_tests();
+  return 0;
+}

tests/001.expected

+{
+  some-int:195
+  array1:[
+    3
+    5.100000e+00
+    -7
+    "nine"
+    T
+    F
+    "last"
+  ]
+  array2:[
+    "/*"
+    "*/"
+  ]
+  some-bool:T
+  other-bool:F
+  some-dbl:-1.000000e-04
+  some-null:null
+  hello:"world!"
+  str1:"//"
+  str2:"\"
+  str3:"text /*text*/ text"
+  str4:"\text\"
+  str5:"\?text\?"
+  str	6\:"text
+text	text"
+  str7:"text\u1234text\u5678"
+  obj:{
+    KEY:"VAL"
+    obj:{
+      KEY:"VAL"
+    }
+  }
+}
+    {
+      "some-int": 195,
+      "array1": [ 3, 5.1, -7, "nine", /*11*/, true, false, "last" ],
+      "array2":["/*","*/"],
+      "some-bool": true,
+      "other-bool": false,
+      "some-dbl": -1e-4,
+      "some-null": null,
+      "hello": "world!",
+      "str1": "//",
+      "str2": "\\",
+      "str3": "text /*text*/ text",
+      "str4": "\\text\\",
+      "str5": "\?text\?",
+      "str\t6\\": "text\ntext\ttext",
+      "str7": "text\u1234text\u5678",
+      //"other": "/OTHER/",
+      "obj": {"KEY":"VAL", "obj":{"KEY":"VAL"}}
+    }
+"unterminated string
+{"key":"val"
+[ "unterminated \string\" ]

tests/005.expected

+[
+  1
+  2
+  3
+  "last"
+]
+// array
+[1,2,3,"last"]

tests/006.expected

+"string value"
+"string value"

tests/007.expected

+T
+true

tests/008.expected

+-1.000000e-02
+-1e-2

tests/009.expected

+null
+null

tests/010.expected

+{
+  glossary:{
+    title:"example glossary"
+    GlossDiv:{
+      title:"S"
+      GlossList:[
+        {
+          ID:"SGML"
+          SortAs:"SGML"
+          GlossTerm:"Standard Generalized Markup Language"
+          Acronym:"SGML"
+          Abbrev:"ISO 8879:1986"
+          GlossDef:"A meta-markup language, used to create markup languages such as DocBook."
+          GlossSeeAlso:[
+            "GML"
+            "XML"
+            "markup"
+          ]
+        }
+      ]
+    }
+  }
+}
+{ "glossary": { /* you */ "title": /**/ "example glossary", /*should*/"GlossDiv": { "title": /*never*/"S", /*ever*/"GlossList": [ { "ID": "SGML", "SortAs": "SGML", "GlossTerm": "Standard Generalized Markup Language", "Acronym": "SGML", "Abbrev": "ISO 8879:1986", "GlossDef": "A meta-markup language, used to create markup languages such as DocBook.", /*see*/"GlossSeeAlso":/*coming*/[/*out*/"GML"/*of*/,/*the*/"XML"/*parser!*/, "markup"] /*hey*/}/*ho*/]/*hey*/}/*ho*/} }  // and the parser won't even get this far, so chill.  /* hah!

tests/011.expected

+{
+  this:"is"
+  really:"simple"
+  json:"right?"
+}
+{
+  "this": "is", // ignore this
+  "really": "simple",
+  /* ignore
+this
+too * / 
+** //
+(/
+******/
+  "json": "right?"
+}

tests/012.expected

+F
+falsex
+{ "123":

tests/014.expected

+1221
+1221 21

tests/015.expected

+{
+}
+
+{}
+{}
+[
+{
+[ "foo", "bar"
+]

tests/020.expected

+[
+  "foo"
+  "bar"
+  "baz"
+  T
+  F
+  null
+  {
+    key:"value"
+  }
+  [
+    null
+    null
+    null
+    [
+    ]
+  ]
+  "
+
+]
+["foo",
+ "bar", "baz",
+ true,false,null,{"key":"value"},
+ [null,null,null,[]],
+ "\n\r\\"
+]

tests/021.expected

+[
+  9223372036854775807
+  -9223372036854775808
+  "end"
+]
+[ 100000000000000000000000000000, -100000000000000000000000000000, "end" ]
+["this","is","what","should","be",
+ "a happy bit of json",
+ "but someone, misspelled \"true\"", ture,
+ "who says JSON is easy for humans to generate?"]

tests/023.expected

+"\u004d\u0430\u4e8c\ud800\udf02"
+"\u004d\u0430\u4e8c\ud800\udf02"

tests/024.expected

+[
+  [
+    [
+      [
+        [
+          [
+            [
+              [
+                [
+                  [
+                    [
+                      [
+                        [
+                          [
+                            [
+                              [
+                                [
+                                  [
+                                    [
+                                      [
+                                        [
+                                          [
+                                            [
+                                              [
+                                                [
+                                                  [
+                                                    [
+                                                      [
+                                                        [
+                                                          [
+                                                            [
+                                                              [
+                                                                [
+                                                                  [
+                                                                    [
+                                                                      [
+                                                                        [
+                                                                          [
+                                                                            [
+                                                                              [
+                                                                                [
+                                                                                  [
+                                                                                    [
+                                                                                      [
+                                                                                        [
+                                                                                          [
+                                                                                            [
+                                                                                              [
+                                                                                                [
+                                                                                                  [
+                                                                                                    [
+                                                                                                      [
+                                                                                                        [
+                                                                                                          [
+                                                                                                            [
+                                                                                                              [
+                                                                                                                [
+                                                                                                                  [
+                                                                                                                    [
+                                                                                                                      [
+                                                                                                                        [
+                                                                                                                          [
+                                                                                                                            [
+                                                                                                                              [
+                                                                                                                                [
+                                                                                                                                  [
+                                                                                                                                    [
+                                                                                                                                      [
+                                                                                                                                        [
+                                                                                                                                          [
+                                                                                                                                            [
+                                                                                                                                              [
+                                                                                                                                                [
+                                                                                                                                                  [
+                                                                                                                                                    [
+                                                                                                                                                      [
+                                                                                                                                                        [
+                                                                                                                                                          [
+                                                                                                                                                            [
+                                                                                                                                                              [
+                                                                                                                                                                [
+                                                                                                                                                                  [
+                                                                                                                                                                    [
+                                                                                                                                                                      [
+                                                                                                                                                                        [
+                                                                                                                                                                          [
+                                                                                                                                                                            [
+                                                                                                                                                                              [
+                                                                                                                                                                                [
+                                                                                                                                                                                  [
+                                                                                                                                                                                    [
+                                                                                                                                                                                      [
+                                                                                                                                                                                        [
+                                                                                                                                                                                          [
+                                                                                                                                                                                            [
+                                                                                                                                                                                              [
+                                                                                                                                                                                                [
+                                                                                                                                                                                                  [
+                                                                                                                                                                                                    [
+                                                                                                                                                                                                      [
+                                                                                                                                                                                                        [
+                                                                                                                                                                                                          [
+                                                                                                                                                                                                            [
+                                                                                                                                                                                                              [
+                                                                                                                                                                                                                [
+                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [
+